/* *  linux/fs/ext2/super.c * * Copyright (C) 1992, 1993, 1994, 1995 * Remy Card (card@masi.ibp.fr) * Laboratoire MASI - Institut Blaise Pascal * Universite Pierre et Marie Curie (Paris VI) * *  from * *  linux/fs/minix/inode.c * *  Copyright (C) 1991, 1992  Linus Torvalds * *  Big-endian to little-endian byte-swapping/bitmaps by *        David S. Miller (davem@caip.rutgers.edu), 1995 */#include <linux/config.h>#include <linux/module.h>#include <linux/string.h>#include <linux/fs.h>#include <linux/ext2_fs.h>#include <linux/slab.h>#include <linux/init.h>#include <linux/locks.h>#include <linux/blkdev.h>#include <asm/uaccess.h>static void ext2_sync_super(struct super_block *sb,			    struct ext2_super_block *es);static char error_buf[1024];void ext2_error (struct super_block * sb, const char * function,		 const char * fmt, ...){	va_list args;	struct ext2_super_block *es = EXT2_SB(sb)->s_es;	if (!(sb->s_flags & MS_RDONLY)) {		sb->u.ext2_sb.s_mount_state |= EXT2_ERROR_FS;		es->s_state =			cpu_to_le16(le16_to_cpu(es->s_state) | EXT2_ERROR_FS);		ext2_sync_super(sb, es);	}	va_start (args, fmt);	vsprintf (error_buf, fmt, args);	va_end (args);	if (test_opt (sb, ERRORS_PANIC) ||	    (le16_to_cpu(sb->u.ext2_sb.s_es->s_errors) == EXT2_ERRORS_PANIC &&	     !test_opt (sb, ERRORS_CONT) && !test_opt (sb, ERRORS_RO)))		panic ("EXT2-fs panic (device %s): %s: %s\n",		       bdevname(sb->s_dev), function, error_buf);	printk (KERN_CRIT "EXT2-fs error (device %s): %s: %s\n",		bdevname(sb->s_dev), function, error_buf);	if (test_opt (sb, ERRORS_RO) ||	    (le16_to_cpu(sb->u.ext2_sb.s_es->s_errors) == EXT2_ERRORS_RO &&	     !test_opt (sb, ERRORS_CONT) && !test_opt (sb, ERRORS_PANIC))) {		printk ("Remounting filesystem read-only\n");		sb->s_flags |= MS_RDONLY;	}}NORET_TYPE void ext2_panic (struct super_block * sb, const char * function,			    const char * fmt, ...){	va_list args;	if (!(sb->s_flags & MS_RDONLY)) {		sb->u.ext2_sb.s_mount_state |= EXT2_ERROR_FS;		sb->u.ext2_sb.s_es->s_state =			cpu_to_le16(le16_to_cpu(sb->u.ext2_sb.s_es->s_state) | EXT2_ERROR_FS);		mark_buffer_dirty(sb->u.ext2_sb.s_sbh);		sb->s_dirt = 1;	}	va_start (args, fmt);	vsprintf (error_buf, fmt, args);	va_end (args);	sb->s_flags |= MS_RDONLY;	panic ("EXT2-fs panic (device %s): %s: %s\n",	       bdevname(sb->s_dev), function, error_buf);}void ext2_warning (struct super_block * sb, const char * function,		   const char * fmt, ...){	va_list args;	va_start (args, fmt);	vsprintf (error_buf, fmt, args);	va_end (args);	printk (KERN_WARNING "EXT2-fs warning (device %s): %s: %s\n",		bdevname(sb->s_dev), function, error_buf);}void ext2_update_dynamic_rev(struct super_block *sb){	struct ext2_super_block *es = EXT2_SB(sb)->s_es;	if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)		return;	ext2_warning(sb, __FUNCTION__,		     "updating to rev %d because of new feature flag, "		     "running e2fsck is recommended",		     EXT2_DYNAMIC_REV);	es->s_first_ino = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO);	es->s_inode_size = cpu_to_le16(EXT2_GOOD_OLD_INODE_SIZE);	es->s_rev_level = cpu_to_le32(EXT2_DYNAMIC_REV);	/* leave es->s_feature_*compat flags alone */	/* es->s_uuid will be set by e2fsck if empty */	/*	 * The rest of the superblock fields should be zero, and if not it	 * means they are likely already in use, so leave them alone.  We	 * can leave it up to e2fsck to clean up any inconsistencies there.	 */}void ext2_put_super (struct super_block * sb){	int db_count;	int i;	if (!(sb->s_flags & MS_RDONLY)) {		struct ext2_super_block *es = EXT2_SB(sb)->s_es;		es->s_state = le16_to_cpu(EXT2_SB(sb)->s_mount_state);		ext2_sync_super(sb, es);	}	db_count = EXT2_SB(sb)->s_gdb_count;	for (i = 0; i < db_count; i++)		if (sb->u.ext2_sb.s_group_desc[i])			brelse (sb->u.ext2_sb.s_group_desc[i]);	kfree(sb->u.ext2_sb.s_group_desc);	for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)		if (sb->u.ext2_sb.s_inode_bitmap[i])			brelse (sb->u.ext2_sb.s_inode_bitmap[i]);	for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)		if (sb->u.ext2_sb.s_block_bitmap[i])			brelse (sb->u.ext2_sb.s_block_bitmap[i]);	brelse (sb->u.ext2_sb.s_sbh);	return;}static struct super_operations ext2_sops = {	read_inode:	ext2_read_inode,	write_inode:	ext2_write_inode,	put_inode:	ext2_put_inode,	delete_inode:	ext2_delete_inode,	put_super:	ext2_put_super,	write_super:	ext2_write_super,	statfs:		ext2_statfs,	remount_fs:	ext2_remount,};/* * This function has been shamelessly adapted from the msdos fs */static int parse_options (char * options, unsigned long * sb_block,			  unsigned short *resuid, unsigned short * resgid,			  unsigned long * mount_options){	char * this_char;	char * value;	if (!options)		return 1;	for (this_char = strtok (options, ",");	     this_char != NULL;	     this_char = strtok (NULL, ",")) {		if ((value = strchr (this_char, '=')) != NULL)			*value++ = 0;		if (!strcmp (this_char, "bsddf"))			clear_opt (*mount_options, MINIX_DF);		else if (!strcmp (this_char, "nouid32")) {			set_opt (*mount_options, NO_UID32);		}		else if (!strcmp (this_char, "check")) {			if (!value || !*value || !strcmp (value, "none"))				clear_opt (*mount_options, CHECK);			else#ifdef CONFIG_EXT2_CHECK				set_opt (*mount_options, CHECK);#else				printk("EXT2 Check option not supported\n");#endif		}		else if (!strcmp (this_char, "debug"))			set_opt (*mount_options, DEBUG);		else if (!strcmp (this_char, "errors")) {			if (!value || !*value) {				printk ("EXT2-fs: the errors option requires "					"an argument\n");				return 0;			}			if (!strcmp (value, "continue")) {				clear_opt (*mount_options, ERRORS_RO);				clear_opt (*mount_options, ERRORS_PANIC);				set_opt (*mount_options, ERRORS_CONT);			}			else if (!strcmp (value, "remount-ro")) {				clear_opt (*mount_options, ERRORS_CONT);				clear_opt (*mount_options, ERRORS_PANIC);				set_opt (*mount_options, ERRORS_RO);			}			else if (!strcmp (value, "panic")) {				clear_opt (*mount_options, ERRORS_CONT);				clear_opt (*mount_options, ERRORS_RO);				set_opt (*mount_options, ERRORS_PANIC);			}			else {				printk ("EXT2-fs: Invalid errors option: %s\n",					value);				return 0;			}		}		else if (!strcmp (this_char, "grpid") ||			 !strcmp (this_char, "bsdgroups"))			set_opt (*mount_options, GRPID);		else if (!strcmp (this_char, "minixdf"))			set_opt (*mount_options, MINIX_DF);		else if (!strcmp (this_char, "nocheck"))			clear_opt (*mount_options, CHECK);		else if (!strcmp (this_char, "nogrpid") ||			 !strcmp (this_char, "sysvgroups"))			clear_opt (*mount_options, GRPID);		else if (!strcmp (this_char, "resgid")) {			if (!value || !*value) {				printk ("EXT2-fs: the resgid option requires "					"an argument\n");				return 0;			}			*resgid = simple_strtoul (value, &value, 0);			if (*value) {				printk ("EXT2-fs: Invalid resgid option: %s\n",					value);				return 0;			}		}		else if (!strcmp (this_char, "resuid")) {			if (!value || !*value) {				printk ("EXT2-fs: the resuid option requires "					"an argument");				return 0;			}			*resuid = simple_strtoul (value, &value, 0);			if (*value) {				printk ("EXT2-fs: Invalid resuid option: %s\n",					value);				return 0;			}		}		else if (!strcmp (this_char, "sb")) {			if (!value || !*value) {				printk ("EXT2-fs: the sb option requires "					"an argument");				return 0;			}			*sb_block = simple_strtoul (value, &value, 0);			if (*value) {				printk ("EXT2-fs: Invalid sb option: %s\n",					value);				return 0;			}		}		/* Silently ignore the quota options */		else if (!strcmp (this_char, "grpquota")		         || !strcmp (this_char, "noquota")		         || !strcmp (this_char, "quota")		         || !strcmp (this_char, "usrquota"))			/* Don't do anything ;-) */ ;		else {			printk ("EXT2-fs: Unrecognized mount option %s\n", this_char);			return 0;		}	}	return 1;}static int ext2_setup_super (struct super_block * sb,			      struct ext2_super_block * es,			      int read_only){	int res = 0;	if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {		printk ("EXT2-fs warning: revision level too high, "			"forcing read-only mode\n");		res = MS_RDONLY;	}	if (read_only)		return res;	if (!(sb->u.ext2_sb.s_mount_state & EXT2_VALID_FS))		printk ("EXT2-fs warning: mounting unchecked fs, "			"running e2fsck is recommended\n");	else if ((sb->u.ext2_sb.s_mount_state & EXT2_ERROR_FS))		printk ("EXT2-fs warning: mounting fs with errors, "			"running e2fsck is recommended\n");	else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&		 le16_to_cpu(es->s_mnt_count) >=		 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))		printk ("EXT2-fs warning: maximal mount count reached, "			"running e2fsck is recommended\n");	else if (le32_to_cpu(es->s_checkinterval) &&		(le32_to_cpu(es->s_lastcheck) + le32_to_cpu(es->s_checkinterval) <= CURRENT_TIME))		printk ("EXT2-fs warning: checktime reached, "			"running e2fsck is recommended\n");	if (!(__s16) le16_to_cpu(es->s_max_mnt_count))		es->s_max_mnt_count = (__s16) cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);	es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);	ext2_write_super(sb);	if (test_opt (sb, DEBUG))		printk ("[EXT II FS %s, %s, bs=%lu, fs=%lu, gc=%lu, "			"bpg=%lu, ipg=%lu, mo=%04lx]\n",			EXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,			sb->u.ext2_sb.s_frag_size,			sb->u.ext2_sb.s_groups_count,			EXT2_BLOCKS_PER_GROUP(sb),			EXT2_INODES_PER_GROUP(sb),			sb->u.ext2_sb.s_mount_opt);#ifdef CONFIG_EXT2_CHECK	if (test_opt (sb, CHECK)) {		ext2_check_blocks_bitmap (sb);		ext2_check_inodes_bitmap (sb);	}#endif	return res;}static int ext2_check_descriptors (struct super_block * sb){	int i;	int desc_block = 0;	unsigned long block = le32_to_cpu(sb->u.ext2_sb.s_es->s_first_data_block);	struct ext2_group_desc * gdp = NULL;	ext2_debug ("Checking group descriptors");	for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++)	{		if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)			gdp = (struct ext2_group_desc *) sb->u.ext2_sb.s_group_desc[desc_block++]->b_data;		if (le32_to_cpu(gdp->bg_block_bitmap) < block ||		    le32_to_cpu(gdp->bg_block_bitmap) >= block + EXT2_BLOCKS_PER_GROUP(sb))		{			ext2_error (sb, "ext2_check_descriptors",				    "Block bitmap for group %d"				    " not in group (block %lu)!",				    i, (unsigned long) le32_to_cpu(gdp->bg_block_bitmap));			return 0;		}		if (le32_to_cpu(gdp->bg_inode_bitmap) < block ||		    le32_to_cpu(gdp->bg_inode_bitmap) >= block + EXT2_BLOCKS_PER_GROUP(sb))		{			ext2_error (sb, "ext2_check_descriptors",				    "Inode bitmap for group %d"				    " not in group (block %lu)!",				    i, (unsigned long) le32_to_cpu(gdp->bg_inode_bitmap));			return 0;		}		if (le32_to_cpu(gdp->bg_inode_table) < block ||		    le32_to_cpu(gdp->bg_inode_table) + sb->u.ext2_sb.s_itb_per_group >=		    block + EXT2_BLOCKS_PER_GROUP(sb))		{			ext2_error (sb, "ext2_check_descriptors",				    "Inode table for group %d"				    " not in group (block %lu)!",				    i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));			return 0;		}		block += EXT2_BLOCKS_PER_GROUP(sb);		gdp++;	}	return 1;}#define log2(n) ffz(~(n)) /* * Maximal file size.  There is a direct, and {,double-,triple-}indirect * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks. * We need to be 1 filesystem block less than the 2^32 sector limit. */static loff_t ext2_max_size(int bits){	loff_t res = EXT2_NDIR_BLOCKS;	res += 1LL << (bits-2);	res += 1LL << (2*(bits-2));	res += 1LL << (3*(bits-2));	res <<= bits;	if (res > (512LL << 32) - (1 << bits))		res = (512LL << 32) - (1 << bits);	return res;}struct super_block * ext2_read_super (struct super_block * sb, void * data,				      int silent){	struct buffer_head * bh;	struct ext2_super_block * es;	unsigned long sb_block = 1;	unsigned short resuid = EXT2_DEF_RESUID;	unsigned short resgid = EXT2_DEF_RESGID;	unsigned long logic_sb_block = 1;	unsigned long offset = 0;	kdev_t dev = sb->s_dev;	int blocksize = BLOCK_SIZE;	int db_count;	int i, j;