自学教程：C++ EXT2_SB函数代码示例

static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs){	struct ext2_sb_info *sbi = EXT2_SB(vfs->mnt_sb);	if (sbi->s_mount_opt & EXT2_MOUNT_GRPID)		seq_puts(seq, ",grpid");#if defined(CONFIG_QUOTA)	if (sbi->s_mount_opt & EXT2_MOUNT_USRQUOTA)		seq_puts(seq, ",usrquota");	if (sbi->s_mount_opt & EXT2_MOUNT_GRPQUOTA)		seq_puts(seq, ",grpquota");#endif#if defined(CONFIG_EXT2_FS_XIP)	if (sbi->s_mount_opt & EXT2_MOUNT_XIP)		seq_puts(seq, ",xip");#endif	return 0;}

static int ext2_sync_fs(struct super_block *sb, int wait){	struct ext2_super_block *es = EXT2_SB(sb)->s_es;	lock_kernel();	if (es->s_state & cpu_to_le16(EXT2_VALID_FS)) {		ext2_debug("setting valid to 0/n");		es->s_state &= cpu_to_le16(~EXT2_VALID_FS);		es->s_free_blocks_count =			cpu_to_le32(ext2_count_free_blocks(sb));		es->s_free_inodes_count =			cpu_to_le32(ext2_count_free_inodes(sb));		es->s_mtime = cpu_to_le32(get_seconds());		ext2_sync_super(sb, es);	} else {		ext2_commit_super(sb, es);	}	sb->s_dirt = 0;	unlock_kernel();	return 0;}

static struct dentry *ext2_get_dentry(struct super_block *sb, void *vobjp){	__u32 *objp = vobjp;	unsigned long ino = objp[0];	__u32 generation = objp[1];	struct inode *inode;	struct dentry *result;	if (ino < EXT2_FIRST_INO(sb) && ino != EXT2_ROOT_INO)		return ERR_PTR(-ESTALE);	if (ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))		return ERR_PTR(-ESTALE);	/* iget isn't really right if the inode is currently unallocated!!	 * ext2_read_inode currently does appropriate checks, but	 * it might be "neater" to call ext2_get_inode first and check	 * if the inode is valid.....	 */	inode = iget(sb, ino);	if (inode == NULL)		return ERR_PTR(-ENOMEM);	if (is_bad_inode(inode) ||	    (generation && inode->i_generation != generation)) {		/* we didn't find the right inode.. */		iput(inode);		return ERR_PTR(-ESTALE);	}	/* now to find a dentry.	 * If possible, get a well-connected one	 */	result = d_alloc_anon(inode);	if (!result) {		iput(inode);		return ERR_PTR(-ENOMEM);	}	return result;}

/* * This must be called with sbi->s_lock held. */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_msg(sb, KERN_WARNING,		     "warning: 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.	 */}

/* * get the group's descriptor of group_num */static const struct ext2_group_desc *ext2_get_group_desc(struct fs_info *fs, uint32_t group_num){    struct ext2_sb_info *sbi = EXT2_SB(fs);    uint32_t desc_block, desc_index;    const struct ext2_group_desc *desc_data_block;    if (group_num >= sbi->s_groups_count) {	printf ("ext2_get_group_desc"		"block_group >= groups_count - "		"block_group = %d, groups_count = %d",		group_num, sbi->s_groups_count);	return NULL;    }    desc_block = group_num / sbi->s_desc_per_block;    desc_index = group_num % sbi->s_desc_per_block;    desc_block += sbi->s_first_data_block + 1;    desc_data_block = get_cache(fs->fs_dev, desc_block);    return &desc_data_block[desc_index];}

static const struct ext2_inode *ext2_get_inode(struct fs_info *fs, int inr){    const struct ext2_group_desc *desc;    const char *data;    uint32_t inode_group, inode_offset;    uint32_t block_num, block_off;    inr--;    inode_group  = inr / EXT2_INODES_PER_GROUP(fs);    inode_offset = inr % EXT2_INODES_PER_GROUP(fs);    desc = ext2_get_group_desc(fs, inode_group);    if (!desc)	return NULL;    block_num = desc->bg_inode_table +	inode_offset / EXT2_INODES_PER_BLOCK(fs);    block_off = inode_offset % EXT2_INODES_PER_BLOCK(fs);    data = get_cache(fs->fs_dev, block_num);    return (const struct ext2_inode *)	(data + block_off * EXT2_SB(fs)->s_inode_size);}

static char *ext2_fs_uuid(struct fs_info *fs){    char *uuid = NULL;    uuid = malloc(EXT2_UUID_LEN);    if (!uuid)	return NULL;    if (snprintf(uuid, EXT2_UUID_LEN,                  "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",	          EXT2_SB(fs)->s_uuid[0],	          EXT2_SB(fs)->s_uuid[1],	          EXT2_SB(fs)->s_uuid[2],	          EXT2_SB(fs)->s_uuid[3],	          EXT2_SB(fs)->s_uuid[4],	          EXT2_SB(fs)->s_uuid[5],	          EXT2_SB(fs)->s_uuid[6],	          EXT2_SB(fs)->s_uuid[7],	          EXT2_SB(fs)->s_uuid[8],	          EXT2_SB(fs)->s_uuid[9],	          EXT2_SB(fs)->s_uuid[10],	          EXT2_SB(fs)->s_uuid[11],	          EXT2_SB(fs)->s_uuid[12],	          EXT2_SB(fs)->s_uuid[13],	          EXT2_SB(fs)->s_uuid[14],	          EXT2_SB(fs)->s_uuid[15]	          ) < 0) {	free(uuid);	return NULL;    }    return uuid;}

//.........这里部分代码省略.........	/* Set defaults before we parse the mount options */	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);	if (def_mount_opts & EXT2_DEFM_DEBUG)		set_opt(sbi->s_mount_opt, DEBUG);	if (def_mount_opts & EXT2_DEFM_BSDGROUPS)		set_opt(sbi->s_mount_opt, GRPID);	if (def_mount_opts & EXT2_DEFM_UID16)		set_opt(sbi->s_mount_opt, NO_UID32);#ifdef CONFIG_EXT2_FS_XATTR	if (def_mount_opts & EXT2_DEFM_XATTR_USER)		set_opt(sbi->s_mount_opt, XATTR_USER);#endif#ifdef CONFIG_EXT2_FS_POSIX_ACL	if (def_mount_opts & EXT2_DEFM_ACL)		set_opt(sbi->s_mount_opt, POSIX_ACL);#endif		if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)		set_opt(sbi->s_mount_opt, ERRORS_PANIC);	else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_CONTINUE)		set_opt(sbi->s_mount_opt, ERRORS_CONT);	else		set_opt(sbi->s_mount_opt, ERRORS_RO);	sbi->s_resuid = le16_to_cpu(es->s_def_resuid);	sbi->s_resgid = le16_to_cpu(es->s_def_resgid);		set_opt(sbi->s_mount_opt, RESERVATION);	if (!parse_options ((char *) data, sbi))		goto failed_mount;	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |		((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?		 MS_POSIXACL : 0);	ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset				    EXT2_MOUNT_XIP if not */	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.	 */	features = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP);	if (features) {		printk("EXT2-fs: %s: couldn't mount because of "		       "unsupported optional features (%x)./n",		       sb->s_id, le32_to_cpu(features));		goto failed_mount;	}	if (!(sb->s_flags & MS_RDONLY) &&	    (features = 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",		       sb->s_id, le32_to_cpu(features));		goto failed_mount;	}	blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);

static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs){	struct super_block *sb = vfs->mnt_sb;	struct ext2_sb_info *sbi = EXT2_SB(sb);	struct ext2_super_block *es = sbi->s_es;	unsigned long def_mount_opts;	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);	if (sbi->s_sb_block != 1)		seq_printf(seq, ",sb=%lu", sbi->s_sb_block);	if (test_opt(sb, MINIX_DF))		seq_puts(seq, ",minixdf");	if (test_opt(sb, GRPID))		seq_puts(seq, ",grpid");	if (!test_opt(sb, GRPID) && (def_mount_opts & EXT2_DEFM_BSDGROUPS))		seq_puts(seq, ",nogrpid");	if (sbi->s_resuid != EXT2_DEF_RESUID ||	    le16_to_cpu(es->s_def_resuid) != EXT2_DEF_RESUID) {		seq_printf(seq, ",resuid=%u", sbi->s_resuid);	}	if (sbi->s_resgid != EXT2_DEF_RESGID ||	    le16_to_cpu(es->s_def_resgid) != EXT2_DEF_RESGID) {		seq_printf(seq, ",resgid=%u", sbi->s_resgid);	}	if (test_opt(sb, ERRORS_RO)) {		int def_errors = le16_to_cpu(es->s_errors);		if (def_errors == EXT2_ERRORS_PANIC ||		    def_errors == EXT2_ERRORS_CONTINUE) {			seq_puts(seq, ",errors=remount-ro");		}	}	if (test_opt(sb, ERRORS_CONT))		seq_puts(seq, ",errors=continue");	if (test_opt(sb, ERRORS_PANIC))		seq_puts(seq, ",errors=panic");	if (test_opt(sb, NO_UID32))		seq_puts(seq, ",nouid32");	if (test_opt(sb, DEBUG))		seq_puts(seq, ",debug");	if (test_opt(sb, OLDALLOC))		seq_puts(seq, ",oldalloc");#ifdef CONFIG_EXT2_FS_XATTR	if (test_opt(sb, XATTR_USER))		seq_puts(seq, ",user_xattr");	if (!test_opt(sb, XATTR_USER) &&	    (def_mount_opts & EXT2_DEFM_XATTR_USER)) {		seq_puts(seq, ",nouser_xattr");	}#endif#ifdef CONFIG_EXT2_FS_POSIX_ACL	if (test_opt(sb, POSIX_ACL))		seq_puts(seq, ",acl");	if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT2_DEFM_ACL))		seq_puts(seq, ",noacl");#endif	if (test_opt(sb, NOBH))		seq_puts(seq, ",nobh");#if defined(CONFIG_QUOTA)	if (sbi->s_mount_opt & EXT2_MOUNT_USRQUOTA)		seq_puts(seq, ",usrquota");	if (sbi->s_mount_opt & EXT2_MOUNT_GRPQUOTA)		seq_puts(seq, ",grpquota");#endif#if defined(CONFIG_EXT2_FS_XIP)	if (sbi->s_mount_opt & EXT2_MOUNT_XIP)		seq_puts(seq, ",xip");#endif	if (!test_opt(sb, RESERVATION))		seq_puts(seq, ",noreservation");	return 0;}

static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf){	struct super_block *sb = dentry->d_sb;	struct ext2_sb_info *sbi = EXT2_SB(sb);	struct ext2_super_block *es = sbi->s_es;	u64 fsid;	if (test_opt (sb, MINIX_DF))		sbi->s_overhead_last = 0;	else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {		unsigned long i, overhead = 0;		smp_rmb();		/*		 * Compute the overhead (FS structures). This is constant		 * for a given filesystem unless the number of block groups		 * changes so we cache the previous value until it does.		 */		/*		 * All of the blocks before first_data_block are		 * overhead		 */		overhead = le32_to_cpu(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 < sbi->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 += (sbi->s_groups_count *			     (2 + sbi->s_itb_per_group));		sbi->s_overhead_last = overhead;		smp_wmb();		sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);	}	buf->f_type = EXT2_SUPER_MAGIC;	buf->f_bsize = sb->s_blocksize;	buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;	buf->f_bfree = ext2_count_free_blocks(sb);	es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);	buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);	if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))		buf->f_bavail = 0;	buf->f_files = le32_to_cpu(es->s_inodes_count);	buf->f_ffree = ext2_count_free_inodes(sb);	es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);	buf->f_namelen = EXT2_NAME_LEN;	fsid = le64_to_cpup((void *)es->s_uuid) ^	       le64_to_cpup((void *)es->s_uuid + sizeof(u64));	buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;	buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;	return 0;}

static int ext2_remount (struct super_block * sb, int * flags, char * data){	struct ext2_sb_info * sbi = EXT2_SB(sb);	struct ext2_super_block * es;	unsigned long old_mount_opt = sbi->s_mount_opt;	struct ext2_mount_options old_opts;	unsigned long old_sb_flags;	int err;	lock_kernel();	/* Store the old options */	old_sb_flags = sb->s_flags;	old_opts.s_mount_opt = sbi->s_mount_opt;	old_opts.s_resuid = sbi->s_resuid;	old_opts.s_resgid = sbi->s_resgid;	/*	 * Allow the "check" option to be passed as a remount option.	 */	if (!parse_options (data, sbi)) {		err = -EINVAL;		goto restore_opts;	}	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |		((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);	ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset				    EXT2_MOUNT_XIP if not */	if ((ext2_use_xip(sb)) && (sb->s_blocksize != PAGE_SIZE)) {		printk("XIP: Unsupported blocksize/n");		err = -EINVAL;		goto restore_opts;	}	es = sbi->s_es;	if (((sbi->s_mount_opt & EXT2_MOUNT_XIP) !=	    (old_mount_opt & EXT2_MOUNT_XIP)) &&	    invalidate_inodes(sb)) {		ext2_warning(sb, __func__, "refusing change of xip flag "			     "with busy inodes while remounting");		sbi->s_mount_opt &= ~EXT2_MOUNT_XIP;		sbi->s_mount_opt |= old_mount_opt & EXT2_MOUNT_XIP;	}	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {		unlock_kernel();		return 0;	}	if (*flags & MS_RDONLY) {		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||		    !(sbi->s_mount_state & EXT2_VALID_FS)) {			unlock_kernel();			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(sbi->s_mount_state);		es->s_mtime = cpu_to_le32(get_seconds());	} else {		__le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,					       ~EXT2_FEATURE_RO_COMPAT_SUPP);		if (ret) {			printk("EXT2-fs: %s: couldn't remount RDWR because of "			       "unsupported optional features (%x)./n",			       sb->s_id, le32_to_cpu(ret));			err = -EROFS;			goto restore_opts;		}		/*		 * 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.)		 */		sbi->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);	unlock_kernel();	return 0;restore_opts:	sbi->s_mount_opt = old_opts.s_mount_opt;	sbi->s_resuid = old_opts.s_resuid;	sbi->s_resgid = old_opts.s_resgid;	sb->s_flags = old_sb_flags;	unlock_kernel();	return err;}

static int ext2_setup_super (struct super_block * sb,			      struct ext2_super_block * es,			      int read_only){	int res = 0;	struct ext2_sb_info *sbi = EXT2_SB(sb);	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;	/* PR 28089 - Allow user to turn off a forced fsck in order	 * to let user to mount a dirty FS RW	 * Thus if FS is dirty and nocheck is the mount option, then	 * FS is mounted RW.	 */	if (!(sbi->s_mount_state & EXT2_VALID_FS)) {		if (!test_opt (sb, CHECK))			printk ("EXT2-fs warning: mounting unclean fs with "			"errors in RW mode./nRunning e2fsck is strongly urged "			"and recommended./n");		else {			printk ("EXT2-fs warning: mounting unchecked fs read-only. "			"Running e2fsck is recommended before re-mounting read-write./n");			sb->s_flags |= MS_RDONLY;			return MS_RDONLY;		}	}	/* PR 28089 - Allow user to turn off a forced fsck in order	 * to let user to mount a dirty FS RW.	 * Thus if FS is dirty and nocheck is the mount option, then	 * FS is mounted RW.	 */	else if ((sbi->s_mount_state & EXT2_ERROR_FS)) {		if (!test_opt (sb, CHECK))			printk ("EXT2-fs warning: mounting unclean fs with "			"errors in RW mode./nRunning e2fsck is strongly urged "			"and recommended./n");		else {			printk ("EXT2-fs warning: mounting unchecked fs read-only. "			"Running e2fsck is recommended before re-mounting read-write./n");			sb->s_flags |= MS_RDONLY;			return MS_RDONLY;		}	}	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. Mounting read-only. "			"Running e2fsck is recommended before re-mounting read-write./n");		sb->s_flags |= MS_RDONLY;		return MS_RDONLY;	}	else if (le32_to_cpu(es->s_checkinterval) &&		(le32_to_cpu(es->s_lastcheck) + le32_to_cpu(es->s_checkinterval) <= get_seconds())) {		printk ("EXT2-fs warning: checktime reached. Mounting read-only. "			"Running e2fsck is recommended before re-mounting read-write./n");		sb->s_flags |= MS_RDONLY;		return MS_RDONLY;	}	if (!le16_to_cpu(es->s_max_mnt_count))		es->s_max_mnt_count = 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,			sbi->s_frag_size,			sbi->s_groups_count,			EXT2_BLOCKS_PER_GROUP(sb),			EXT2_INODES_PER_GROUP(sb),			sbi->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;}

struct super_block * ext2_read_super (struct super_block * sb, void * data,				      int silent){	struct buffer_head * bh;  	struct ext2_sb_info * sbi = EXT2_SB(sb);	struct ext2_super_block * es;	unsigned long sb_block = 1;	unsigned short resuid = EXT2_DEF_RESUID;	unsigned short resgid = EXT2_DEF_RESGID;	unsigned long block;	unsigned long logic_sb_block;	unsigned long offset = 0;	kdev_t dev = sb->s_dev;	int blocksize = BLOCK_SIZE;	int db_count;	int i, j;	/*	 * 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;	} else {		logic_sb_block = sb_block;	}	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;	}	if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))		ext2_warning(sb, __FUNCTION__,			"mounting ext3 filesystem as ext2/n");	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;//.........这里部分代码省略.........

static int parse_options(char *options, struct super_block *sb){	char *p;	struct ext2_sb_info *sbi = EXT2_SB(sb);	substring_t args[MAX_OPT_ARGS];	int option;	if (!options)		return 1;	while ((p = strsep (&options, ",")) != NULL) {		int token;		if (!*p)			continue;		token = match_token(p, tokens, args);		switch (token) {		case Opt_bsd_df:			clear_opt (sbi->s_mount_opt, MINIX_DF);			break;		case Opt_minix_df:			set_opt (sbi->s_mount_opt, MINIX_DF);			break;		case Opt_grpid:			set_opt (sbi->s_mount_opt, GRPID);			break;		case Opt_nogrpid:			clear_opt (sbi->s_mount_opt, GRPID);			break;		case Opt_resuid:			if (match_int(&args[0], &option))				return 0;			sbi->s_resuid = option;			break;		case Opt_resgid:			if (match_int(&args[0], &option))				return 0;			sbi->s_resgid = option;			break;		case Opt_sb:			/* handled by get_sb_block() instead of here */			/* *sb_block = match_int(&args[0]); */			break;		case Opt_err_panic:			clear_opt (sbi->s_mount_opt, ERRORS_CONT);			clear_opt (sbi->s_mount_opt, ERRORS_RO);			set_opt (sbi->s_mount_opt, ERRORS_PANIC);			break;		case Opt_err_ro:			clear_opt (sbi->s_mount_opt, ERRORS_CONT);			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);			set_opt (sbi->s_mount_opt, ERRORS_RO);			break;		case Opt_err_cont:			clear_opt (sbi->s_mount_opt, ERRORS_RO);			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);			set_opt (sbi->s_mount_opt, ERRORS_CONT);			break;		case Opt_nouid32:			set_opt (sbi->s_mount_opt, NO_UID32);			break;		case Opt_nocheck:			clear_opt (sbi->s_mount_opt, CHECK);			break;		case Opt_debug:			set_opt (sbi->s_mount_opt, DEBUG);			break;		case Opt_oldalloc:			set_opt (sbi->s_mount_opt, OLDALLOC);			break;		case Opt_orlov:			clear_opt (sbi->s_mount_opt, OLDALLOC);			break;		case Opt_nobh:			set_opt (sbi->s_mount_opt, NOBH);			break;#ifdef CONFIG_EXT2_FS_XATTR		case Opt_user_xattr:			set_opt (sbi->s_mount_opt, XATTR_USER);			break;		case Opt_nouser_xattr:			clear_opt (sbi->s_mount_opt, XATTR_USER);			break;#else		case Opt_user_xattr:		case Opt_nouser_xattr:			ext2_msg(sb, KERN_INFO, "(no)user_xattr options"				"not supported");			break;#endif#ifdef CONFIG_EXT2_FS_POSIX_ACL		case Opt_acl:			set_opt(sbi->s_mount_opt, POSIX_ACL);			break;		case Opt_noacl:			clear_opt(sbi->s_mount_opt, POSIX_ACL);			break;#else		case Opt_acl:		case Opt_noacl://.........这里部分代码省略.........

//.........这里部分代码省略.........	/* Set defaults before we parse the mount options */	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);	if (def_mount_opts & EXT2_DEFM_DEBUG)		set_opt(sbi->s_mount_opt, DEBUG);	if (def_mount_opts & EXT2_DEFM_BSDGROUPS)		set_opt(sbi->s_mount_opt, GRPID);	if (def_mount_opts & EXT2_DEFM_UID16)		set_opt(sbi->s_mount_opt, NO_UID32);#ifdef CONFIG_EXT2_FS_XATTR	if (def_mount_opts & EXT2_DEFM_XATTR_USER)		set_opt(sbi->s_mount_opt, XATTR_USER);#endif#ifdef CONFIG_EXT2_FS_POSIX_ACL	if (def_mount_opts & EXT2_DEFM_ACL)		set_opt(sbi->s_mount_opt, POSIX_ACL);#endif		if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)		set_opt(sbi->s_mount_opt, ERRORS_PANIC);	else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_CONTINUE)		set_opt(sbi->s_mount_opt, ERRORS_CONT);	else		set_opt(sbi->s_mount_opt, ERRORS_RO);	sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));	sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));		set_opt(sbi->s_mount_opt, RESERVATION);	if (!parse_options((char *) data, sb))		goto failed_mount;	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |		((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?		 MS_POSIXACL : 0);	sb->s_iflags |= SB_I_CGROUPWB;	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)))		ext2_msg(sb, KERN_WARNING,			"warning: feature flags set on rev 0 fs, "			"running e2fsck is recommended");	/*	 * 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.	 */	features = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP);	if (features) {		ext2_msg(sb, KERN_ERR,	"error: couldn't mount because of "		       "unsupported optional features (%x)",			le32_to_cpu(features));		goto failed_mount;	}	if (!(sb->s_flags & MS_RDONLY) &&	    (features = EXT2_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP))){		ext2_msg(sb, KERN_ERR, "error: couldn't mount RDWR because of "		       "unsupported optional features (%x)",		       le32_to_cpu(features));		goto failed_mount;	}	blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);

static int ext2_remount (struct super_block * sb, int * flags, char * data){	struct ext2_sb_info * sbi = EXT2_SB(sb);	struct ext2_super_block * es;	struct ext2_mount_options old_opts;	unsigned long old_sb_flags;	int err;	sync_filesystem(sb);	spin_lock(&sbi->s_lock);	/* Store the old options */	old_sb_flags = sb->s_flags;	old_opts.s_mount_opt = sbi->s_mount_opt;	old_opts.s_resuid = sbi->s_resuid;	old_opts.s_resgid = sbi->s_resgid;	/*	 * Allow the "check" option to be passed as a remount option.	 */	if (!parse_options(data, sb)) {		err = -EINVAL;		goto restore_opts;	}	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |		((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);	es = sbi->s_es;	if ((sbi->s_mount_opt ^ old_opts.s_mount_opt) & EXT2_MOUNT_DAX) {		ext2_msg(sb, KERN_WARNING, "warning: refusing change of "			 "dax flag with busy inodes while remounting");		sbi->s_mount_opt ^= EXT2_MOUNT_DAX;	}	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {		spin_unlock(&sbi->s_lock);		return 0;	}	if (*flags & MS_RDONLY) {		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||		    !(sbi->s_mount_state & EXT2_VALID_FS)) {			spin_unlock(&sbi->s_lock);			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(sbi->s_mount_state);		es->s_mtime = cpu_to_le32(get_seconds());		spin_unlock(&sbi->s_lock);		err = dquot_suspend(sb, -1);		if (err < 0) {			spin_lock(&sbi->s_lock);			goto restore_opts;		}		ext2_sync_super(sb, es, 1);	} else {		__le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,					       ~EXT2_FEATURE_RO_COMPAT_SUPP);		if (ret) {			ext2_msg(sb, KERN_WARNING,				"warning: couldn't remount RDWR because of "				"unsupported optional features (%x).",				le32_to_cpu(ret));			err = -EROFS;			goto restore_opts;		}		/*		 * 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.)		 */		sbi->s_mount_state = le16_to_cpu(es->s_state);		if (!ext2_setup_super (sb, es, 0))			sb->s_flags &= ~MS_RDONLY;		spin_unlock(&sbi->s_lock);		ext2_write_super(sb);		dquot_resume(sb, -1);	}	return 0;restore_opts:	sbi->s_mount_opt = old_opts.s_mount_opt;	sbi->s_resuid = old_opts.s_resuid;	sbi->s_resgid = old_opts.s_resgid;	sb->s_flags = old_sb_flags;	spin_unlock(&sbi->s_lock);	return err;}

static int parse_options(char *options, struct super_block *sb){	char *p;	struct ext2_sb_info *sbi = EXT2_SB(sb);	substring_t args[MAX_OPT_ARGS];	int option;	kuid_t uid;	kgid_t gid;	if (!options)		return 1;	while ((p = strsep (&options, ",")) != NULL) {		int token;		if (!*p)			continue;		token = match_token(p, tokens, args);		switch (token) {		case Opt_bsd_df:			clear_opt (sbi->s_mount_opt, MINIX_DF);			break;		case Opt_minix_df:			set_opt (sbi->s_mount_opt, MINIX_DF);			break;		case Opt_grpid:			set_opt (sbi->s_mount_opt, GRPID);			break;		case Opt_nogrpid:			clear_opt (sbi->s_mount_opt, GRPID);			break;		case Opt_resuid:			if (match_int(&args[0], &option))				return 0;			uid = make_kuid(current_user_ns(), option);			if (!uid_valid(uid)) {				ext2_msg(sb, KERN_ERR, "Invalid uid value %d", option);				return 0;			}			sbi->s_resuid = uid;			break;		case Opt_resgid:			if (match_int(&args[0], &option))				return 0;			gid = make_kgid(current_user_ns(), option);			if (!gid_valid(gid)) {				ext2_msg(sb, KERN_ERR, "Invalid gid value %d", option);				return 0;			}			sbi->s_resgid = gid;			break;		case Opt_sb:			/* handled by get_sb_block() instead of here */			/* *sb_block = match_int(&args[0]); */			break;		case Opt_err_panic:			clear_opt (sbi->s_mount_opt, ERRORS_CONT);			clear_opt (sbi->s_mount_opt, ERRORS_RO);			set_opt (sbi->s_mount_opt, ERRORS_PANIC);			break;		case Opt_err_ro:			clear_opt (sbi->s_mount_opt, ERRORS_CONT);			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);			set_opt (sbi->s_mount_opt, ERRORS_RO);			break;		case Opt_err_cont:			clear_opt (sbi->s_mount_opt, ERRORS_RO);			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);			set_opt (sbi->s_mount_opt, ERRORS_CONT);			break;		case Opt_nouid32:			set_opt (sbi->s_mount_opt, NO_UID32);			break;		case Opt_nocheck:			clear_opt (sbi->s_mount_opt, CHECK);			break;		case Opt_debug:			set_opt (sbi->s_mount_opt, DEBUG);			break;		case Opt_oldalloc:			set_opt (sbi->s_mount_opt, OLDALLOC);			break;		case Opt_orlov:			clear_opt (sbi->s_mount_opt, OLDALLOC);			break;		case Opt_nobh:			set_opt (sbi->s_mount_opt, NOBH);			break;#ifdef CONFIG_EXT2_FS_XATTR		case Opt_user_xattr:			set_opt (sbi->s_mount_opt, XATTR_USER);			break;		case Opt_nouser_xattr:			clear_opt (sbi->s_mount_opt, XATTR_USER);			break;#else		case Opt_user_xattr:		case Opt_nouser_xattr:			ext2_msg(sb, KERN_INFO, "(no)user_xattr options"//.........这里部分代码省略.........