/*	 * See what the current blocksize for the device is, and	 * use that as the blocksize.  Otherwise (or if the blocksize	 * is smaller than the default) use the default.	 * This is important for devices that have a hardware	 * sectorsize that is larger than the default.	 */	blocksize = get_hardsect_size(dev);	if(blocksize < BLOCK_SIZE )	    blocksize = BLOCK_SIZE;	sb->u.ext2_sb.s_mount_opt = 0;	if (!parse_options ((char *) data, &sb_block, &resuid, &resgid,	    &sb->u.ext2_sb.s_mount_opt)) {		return NULL;	}	if (set_blocksize(dev, blocksize) < 0) {		printk ("EXT2-fs: unable to set blocksize %d\n", blocksize);		return NULL;	}	sb->s_blocksize = blocksize;	/*	 * If the superblock doesn't start on a sector boundary,	 * calculate the offset.  FIXME(eric) this doesn't make sense	 * that we would have to do this.	 */	if (blocksize != BLOCK_SIZE) {		logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;		offset = (sb_block*BLOCK_SIZE) % blocksize;	}	if (!(bh = sb_bread(sb, logic_sb_block))) {		printk ("EXT2-fs: unable to read superblock\n");		return NULL;	}	/*	 * Note: s_es must be initialized as soon as possible because	 *       some ext2 macro-instructions depend on its value	 */	es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);	sb->u.ext2_sb.s_es = es;	sb->s_magic = le16_to_cpu(es->s_magic);	if (sb->s_magic != EXT2_SUPER_MAGIC) {		if (!silent)			printk ("VFS: Can't find ext2 filesystem on dev %s.\n",				bdevname(dev));		goto failed_mount;	}	if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&	    (EXT2_HAS_COMPAT_FEATURE(sb, ~0U) ||	     EXT2_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||	     EXT2_HAS_INCOMPAT_FEATURE(sb, ~0U)))		printk("EXT2-fs warning: feature flags set on rev 0 fs, "		       "running e2fsck is recommended\n");	/*	 * Check feature flags regardless of the revision level, since we	 * previously didn't change the revision level when setting the flags,	 * so there is a chance incompat flags are set on a rev 0 filesystem.	 */	if ((i = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP))) {		printk("EXT2-fs: %s: couldn't mount because of "		       "unsupported optional features (%x).\n",		       bdevname(dev), i);		goto failed_mount;	}	if (!(sb->s_flags & MS_RDONLY) &&	    (i = EXT2_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP))){		printk("EXT2-fs: %s: couldn't mount RDWR because of "		       "unsupported optional features (%x).\n",		       bdevname(dev), i);		goto failed_mount;	}	sb->s_blocksize_bits =		le32_to_cpu(EXT2_SB(sb)->s_es->s_log_block_size) + 10;	sb->s_blocksize = 1 << sb->s_blocksize_bits;	sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);	/* If the blocksize doesn't match, re-read the thing.. */	if (sb->s_blocksize != blocksize) {		blocksize = sb->s_blocksize;		brelse(bh);		if (set_blocksize(dev, blocksize) < 0) {			printk(KERN_ERR "EXT2-fs: blocksize too small for device.\n");			return NULL;		}		logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;		offset = (sb_block*BLOCK_SIZE) % blocksize;		bh = sb_bread(sb, logic_sb_block);		if(!bh) {			printk("EXT2-fs: Couldn't read superblock on "			       "2nd try.\n");			goto failed_mount;		}		es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);		sb->u.ext2_sb.s_es = es;		if (es->s_magic != le16_to_cpu(EXT2_SUPER_MAGIC)) {			printk ("EXT2-fs: Magic mismatch, very weird !\n");			goto failed_mount;		}	}	if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {		sb->u.ext2_sb.s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;		sb->u.ext2_sb.s_first_ino = EXT2_GOOD_OLD_FIRST_INO;	} else {		sb->u.ext2_sb.s_inode_size = le16_to_cpu(es->s_inode_size);		sb->u.ext2_sb.s_first_ino = le32_to_cpu(es->s_first_ino);		if (sb->u.ext2_sb.s_inode_size != EXT2_GOOD_OLD_INODE_SIZE) {			printk ("EXT2-fs: unsupported inode size: %d\n",				sb->u.ext2_sb.s_inode_size);			goto failed_mount;		}	}	sb->u.ext2_sb.s_frag_size = EXT2_MIN_FRAG_SIZE <<				   le32_to_cpu(es->s_log_frag_size);	if (sb->u.ext2_sb.s_frag_size)		sb->u.ext2_sb.s_frags_per_block = sb->s_blocksize /						  sb->u.ext2_sb.s_frag_size;	else		sb->s_magic = 0;	sb->u.ext2_sb.s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);	sb->u.ext2_sb.s_frags_per_group = le32_to_cpu(es->s_frags_per_group);	sb->u.ext2_sb.s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);	sb->u.ext2_sb.s_inodes_per_block = sb->s_blocksize /					   EXT2_INODE_SIZE(sb);	sb->u.ext2_sb.s_itb_per_group = sb->u.ext2_sb.s_inodes_per_group /				        sb->u.ext2_sb.s_inodes_per_block;	sb->u.ext2_sb.s_desc_per_block = sb->s_blocksize /					 sizeof (struct ext2_group_desc);	sb->u.ext2_sb.s_sbh = bh;	if (resuid != EXT2_DEF_RESUID)		sb->u.ext2_sb.s_resuid = resuid;	else		sb->u.ext2_sb.s_resuid = le16_to_cpu(es->s_def_resuid);	if (resgid != EXT2_DEF_RESGID)		sb->u.ext2_sb.s_resgid = resgid;	else		sb->u.ext2_sb.s_resgid = le16_to_cpu(es->s_def_resgid);	sb->u.ext2_sb.s_mount_state = le16_to_cpu(es->s_state);	sb->u.ext2_sb.s_addr_per_block_bits =		log2 (EXT2_ADDR_PER_BLOCK(sb));	sb->u.ext2_sb.s_desc_per_block_bits =		log2 (EXT2_DESC_PER_BLOCK(sb));	if (sb->s_magic != EXT2_SUPER_MAGIC) {		if (!silent)			printk ("VFS: Can't find an ext2 filesystem on dev "				"%s.\n",				bdevname(dev));		goto failed_mount;	}	if (sb->s_blocksize != bh->b_size) {		if (!silent)			printk ("VFS: Unsupported blocksize on dev "				"%s.\n", bdevname(dev));		goto failed_mount;	}	if (sb->s_blocksize != sb->u.ext2_sb.s_frag_size) {		printk ("EXT2-fs: fragsize %lu != blocksize %lu (not supported yet)\n",			sb->u.ext2_sb.s_frag_size, sb->s_blocksize);		goto failed_mount;	}	if (sb->u.ext2_sb.s_blocks_per_group > sb->s_blocksize * 8) {		printk ("EXT2-fs: #blocks per group too big: %lu\n",			sb->u.ext2_sb.s_blocks_per_group);		goto failed_mount;	}	if (sb->u.ext2_sb.s_frags_per_group > sb->s_blocksize * 8) {		printk ("EXT2-fs: #fragments per group too big: %lu\n",			sb->u.ext2_sb.s_frags_per_group);		goto failed_mount;	}	if (sb->u.ext2_sb.s_inodes_per_group > sb->s_blocksize * 8) {		printk ("EXT2-fs: #inodes per group too big: %lu\n",			sb->u.ext2_sb.s_inodes_per_group);		goto failed_mount;	}	sb->u.ext2_sb.s_groups_count = (le32_to_cpu(es->s_blocks_count) -				        le32_to_cpu(es->s_first_data_block) +				       EXT2_BLOCKS_PER_GROUP(sb) - 1) /				       EXT2_BLOCKS_PER_GROUP(sb);	db_count = (sb->u.ext2_sb.s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /		   EXT2_DESC_PER_BLOCK(sb);	sb->u.ext2_sb.s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);	if (sb->u.ext2_sb.s_group_desc == NULL) {		printk ("EXT2-fs: not enough memory\n");		goto failed_mount;	}	for (i = 0; i < db_count; i++) {		sb->u.ext2_sb.s_group_desc[i] = sb_bread(sb, logic_sb_block + i + 1);		if (!sb->u.ext2_sb.s_group_desc[i]) {			for (j = 0; j < i; j++)				brelse (sb->u.ext2_sb.s_group_desc[j]);			kfree(sb->u.ext2_sb.s_group_desc);			printk ("EXT2-fs: unable to read group descriptors\n");			goto failed_mount;		}	}	if (!ext2_check_descriptors (sb)) {		printk ("EXT2-fs: group descriptors corrupted!\n");		db_count = i;		goto failed_mount2;	}	for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++) {		sb->u.ext2_sb.s_inode_bitmap_number[i] = 0;		sb->u.ext2_sb.s_inode_bitmap[i] = NULL;		sb->u.ext2_sb.s_block_bitmap_number[i] = 0;		sb->u.ext2_sb.s_block_bitmap[i] = NULL;	}	sb->u.ext2_sb.s_loaded_inode_bitmaps = 0;	sb->u.ext2_sb.s_loaded_block_bitmaps = 0;	sb->u.ext2_sb.s_gdb_count = db_count;	/*	 * set up enough so that it can read an inode	 */	sb->s_op = &ext2_sops;	sb->s_root = d_alloc_root(iget(sb, EXT2_ROOT_INO));	if (!sb->s_root || !S_ISDIR(sb->s_root->d_inode->i_mode) ||	    !sb->s_root->d_inode->i_blocks || !sb->s_root->d_inode->i_size) {		if (sb->s_root) {			dput(sb->s_root);			sb->s_root = NULL;			printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");		} else			printk(KERN_ERR "EXT2-fs: get root inode failed\n");		goto failed_mount2;	}	ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);	return sb;failed_mount2:	for (i = 0; i < db_count; i++)		brelse(sb->u.ext2_sb.s_group_desc[i]);	kfree(sb->u.ext2_sb.s_group_desc);failed_mount:	brelse(bh);	return NULL;}static void ext2_commit_super (struct super_block * sb,			       struct ext2_super_block * es){	es->s_wtime = cpu_to_le32(CURRENT_TIME);	mark_buffer_dirty(sb->u.ext2_sb.s_sbh);	sb->s_dirt = 0;}static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es){	es->s_wtime = cpu_to_le32(CURRENT_TIME);	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);	ll_rw_block(WRITE, 1, &EXT2_SB(sb)->s_sbh);	wait_on_buffer(EXT2_SB(sb)->s_sbh);	sb->s_dirt = 0;}/* * In the second extended file system, it is not necessary to * write the super block since we use a mapping of the * disk super block in a buffer. * * However, this function is still used to set the fs valid * flags to 0.  We need to set this flag to 0 since the fs * may have been checked while mounted and e2fsck may have * set s_state to EXT2_VALID_FS after some corrections. */void ext2_write_super (struct super_block * sb){	struct ext2_super_block * es;	if (!(sb->s_flags & MS_RDONLY)) {		es = sb->u.ext2_sb.s_es;		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS) {			ext2_debug ("setting valid to 0\n");			es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) &						  ~EXT2_VALID_FS);			es->s_mtime = cpu_to_le32(CURRENT_TIME);			ext2_sync_super(sb, es);		} else			ext2_commit_super (sb, es);	}	sb->s_dirt = 0;}int ext2_remount (struct super_block * sb, int * flags, char * data){	struct ext2_super_block * es;	unsigned short resuid = sb->u.ext2_sb.s_resuid;	unsigned short resgid = sb->u.ext2_sb.s_resgid;	unsigned long new_mount_opt;	unsigned long tmp;	/*	 * Allow the "check" option to be passed as a remount option.	 */	new_mount_opt = sb->u.ext2_sb.s_mount_opt;	if (!parse_options (data, &tmp, &resuid, &resgid,			    &new_mount_opt))		return -EINVAL;	sb->u.ext2_sb.s_mount_opt = new_mount_opt;	sb->u.ext2_sb.s_resuid = resuid;	sb->u.ext2_sb.s_resgid = resgid;	es = sb->u.ext2_sb.s_es;	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))		return 0;	if (*flags & MS_RDONLY) {		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||		    !(sb->u.ext2_sb.s_mount_state & EXT2_VALID_FS))			return 0;		/*		 * OK, we are remounting a valid rw partition rdonly, so set		 * the rdonly flag and then mark the partition as valid again.		 */		es->s_state = cpu_to_le16(sb->u.ext2_sb.s_mount_state);		es->s_mtime = cpu_to_le32(CURRENT_TIME);	} else {		int ret;		if ((ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,					       ~EXT2_FEATURE_RO_COMPAT_SUPP))) {			printk("EXT2-fs: %s: couldn't remount RDWR because of "			       "unsupported optional features (%x).\n",			       bdevname(sb->s_dev), ret);			return -EROFS;		}		/*		 * Mounting a RDONLY partition read-write, so reread and		 * store the current valid flag.  (It may have been changed		 * by e2fsck since we originally mounted the partition.)		 */		sb->u.ext2_sb.s_mount_state = le16_to_cpu(es->s_state);		if (!ext2_setup_super (sb, es, 0))			sb->s_flags &= ~MS_RDONLY;	}	ext2_sync_super(sb, es);	return 0;}int ext2_statfs (struct super_block * sb, struct statfs * buf){	unsigned long overhead;	int i;	if (test_opt (sb, MINIX_DF))		overhead = 0;	else {		/*		 * Compute the overhead (FS structures)		 */		/*		 * All of the blocks before first_data_block are		 * overhead		 */		overhead = le32_to_cpu(sb->u.ext2_sb.s_es->s_first_data_block);		/*		 * Add the overhead attributed to the superblock and		 * block group descriptors.  If the sparse superblocks		 * feature is turned on, then not all groups have this.		 */		for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++)			overhead += ext2_bg_has_super(sb, i) +				ext2_bg_num_gdb(sb, i);		/*		 * Every block group has an inode bitmap, a block		 * bitmap, and an inode table.		 */		overhead += (sb->u.ext2_sb.s_groups_count *			     (2 + sb->u.ext2_sb.s_itb_per_group));	}	buf->f_type = EXT2_SUPER_MAGIC;	buf->f_bsize = sb->s_blocksize;	buf->f_blocks = le32_to_cpu(sb->u.ext2_sb.s_es->s_blocks_count) - overhead;	buf->f_bfree = ext2_count_free_blocks (sb);	buf->f_bavail = buf->f_bfree - le32_to_cpu(sb->u.ext2_sb.s_es->s_r_blocks_count);	if (buf->f_bfree < le32_to_cpu(sb->u.ext2_sb.s_es->s_r_blocks_count))		buf->f_bavail = 0;	buf->f_files = le32_to_cpu(sb->u.ext2_sb.s_es->s_inodes_count);	buf->f_ffree = ext2_count_free_inodes (sb);	buf->f_namelen = EXT2_NAME_LEN;	return 0;}static DECLARE_FSTYPE_DEV(ext2_fs_type, "ext2", ext2_read_super);static int __init init_ext2_fs(void){        return register_filesystem(&ext2_fs_type);}static void __exit exit_ext2_fs(void){	unregister_filesystem(&ext2_fs_type);}EXPORT_NO_SYMBOLS;module_init(init_ext2_fs)module_exit(exit_ext2_fs)