ext2文件系统源代码之super.c

桃扇骨 2022-07-29 09:24 228阅读 0赞

今天来看一个ext2文件系统里的super.c文件，这个文件的内容是文件系统里的超级块的相关函数，对于文件系统有很大的重要性，并且这个文件也很长，好啦，我们开始看吧。

/* 日常作者信息
     *  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/module.h>
    #include <linux/string.h>
    #include <linux/fs.h>
    #include <linux/slab.h>
    #include <linux/init.h>
    #include <linux/blkdev.h>
    #include <linux/parser.h>
    #include <linux/random.h>
    #include <linux/buffer_head.h>
    #include <linux/smp_lock.h>
    #include <linux/vfs.h>
    #include <linux/seq_file.h>
    #include <linux/mount.h>
    #include <asm/uaccess.h>
    #include "ext2.h"
    #include "xattr.h"
    #include "acl.h"
    #include "xip.h"
    
    
    /*函数声明，超级块的同步函数，重新挂载文件系统的函数以及得到文件系统状态的函数*/
    static void ext2_sync_super(struct super_block *sb,
    			    struct ext2_super_block *es);
    static int ext2_remount (struct super_block * sb, int * flags, char * data);
    static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf);
    
    
    /*ext2的打印错误信息的函数，参数有可变参数*/
    void ext2_error (struct super_block * sb, const char * function,
    		 const char * fmt, ...)
    {
    	va_list args;
    	/*内存里存放的超级块信息结构体*/
    	struct ext2_sb_info *sbi = EXT2_SB(sb);
    	/*ext2硬盘上存放的超级块*/
    	struct ext2_super_block *es = sbi->s_es;
    	/*如果文件系统不是只读的*/
    	if (!(sb->s_flags & MS_RDONLY)) {
    		/*出错了，就在ext2_sb_info结构体的对应位上或上对应位，标记文件系统有错误发生*/
    		sbi->s_mount_state |= EXT2_ERROR_FS;
    		/*ext2_super_block结构体上对应位置位，标识文件系统有错误发生*/
    		es->s_state =
    			cpu_to_le16(le16_to_cpu(es->s_state) | EXT2_ERROR_FS);
    		/*超级块立即同步*/
    		ext2_sync_super(sb, es);
    	}
    	/*打印出错的信息*/
    	va_start(args, fmt);
    	printk(KERN_CRIT "EXT2-fs error (device %s): %s: ",sb->s_id, function);
    	vprintk(fmt, args);
    	printk("\n");
    	va_end(args);
    	/*如果是严重错误，打印相应的信息*/
    	if (test_opt(sb, ERRORS_PANIC))
    		panic("EXT2-fs panic from previous error\n");
    	/*如果是只读错误，就打印应当把文件系统重新只读挂载*/
    	if (test_opt(sb, ERRORS_RO)) {
    		printk("Remounting filesystem read-only\n");
    		/*超级块对应位设置为只读*/
    		sb->s_flags |= MS_RDONLY;
    	}
    }
    /*打印警告信息，错误不是很严重*/
    void ext2_warning (struct super_block * sb, const char * function,
    		   const char * fmt, ...)
    {
    	va_list args;
    	/*仅仅是简单的打印信息*/
    	va_start(args, fmt);
    	printk(KERN_WARNING "EXT2-fs warning (device %s): %s: ",
    	       sb->s_id, function);
    	vprintk(fmt, args);
    	printk("\n");
    	va_end(args);
    }
    /*更新文件系统为动态的inode的修改级别*/
    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);
    	/*设置第一个inode号，inode大小*/
    	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);
    	/* 此处不处理 es->s_feature_*compat*/
    	/* es->s_uuid会被e2fsck处理 */
    
    
    	/* 超级块的其他字段应该是0，如果不是，说明他们正在被使用，我们可以接下来让e2fsck来解决*/
    }
    /*释放正在使用的超级块*/
    static void ext2_put_super (struct super_block * sb)
    {
    	int db_count;
    	int i;
    	struct ext2_sb_info *sbi = EXT2_SB(sb);
    	/*释放这个超级块的块设备的所有在内存里的缓冲区*/
    	ext2_xattr_put_super(sb);
    	/*如果文件系统不是只读挂载的*/
    	if (!(sb->s_flags & MS_RDONLY)) {
    		struct ext2_super_block *es = sbi->s_es;
    		/*同步文件系统的挂载状态*/
    		es->s_state = cpu_to_le16(sbi->s_mount_state);
    		ext2_sync_super(sb, es);
    	}
    	/*文件系统的组描述符数目*/
    	db_count = sbi->s_gdb_count;
    	/*遍历所有的组，释放所有的组描述符的缓冲区*/
    	for (i = 0; i < db_count; i++)
    		if (sbi->s_group_desc[i])
    			brelse (sbi->s_group_desc[i]);
    	/*释放组描述符数组和文件系统负载数组*/
    	kfree(sbi->s_group_desc);
    	kfree(sbi->s_debts);
    	/*释放者三个结构体*/
    	percpu_counter_destroy(&sbi->s_freeblocks_counter);
    	percpu_counter_destroy(&sbi->s_freeinodes_counter);
    	percpu_counter_destroy(&sbi->s_dirs_counter);
    	brelse (sbi->s_sbh);
    	sb->s_fs_info = NULL;
    	/*释放ext2_sb_info结构体*/
    	kfree(sbi);
    
    
    	return;
    }
    /*用来存放ext2的inode的缓冲区*/
    static struct kmem_cache * ext2_inode_cachep;
    /*ext2分配一个空的inode*/
    static struct inode *ext2_alloc_inode(struct super_block *sb)
    {
    	struct ext2_inode_info *ei;
    	/*先从ext2_inode_cachep上分配内存对应的ext2_inode_info结构体*/
    	ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, GFP_KERNEL);
    	if (!ei)
    		return NULL;
    	/*配置了acl，先初始化acl为没有映射状态*/
    #ifdef CONFIG_EXT2_FS_POSIX_ACL
    	ei->i_acl = EXT2_ACL_NOT_CACHED;
    	ei->i_default_acl = EXT2_ACL_NOT_CACHED;
    #endif
    	/*版本号*/
    	ei->vfs_inode.i_version = 1;
    	return &ei->vfs_inode;
    }
    /*释放一个inode*/
    static void ext2_destroy_inode(struct inode *inode)
    {
    	/*调用内存的缓冲释放函数，从ext2_inode_cachep上释放*/
    	kmem_cache_free(ext2_inode_cachep, EXT2_I(inode));
    }
    /*初始化ext2_inode_info的指针*/
    static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
    {
    	/*先转化获得ext2_inode_info指针*/
    	struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
    	/*逐个初始化读写锁，属性锁*/
    	rwlock_init(&ei->i_meta_lock);
    #ifdef CONFIG_EXT2_FS_XATTR
    	init_rwsem(&ei->xattr_sem);
    #endif
    	/*初始化vfs层的inode*/
    	inode_init_once(&ei->vfs_inode);
    }
     /*初始化ext2_inode_cachep的缓冲区*/
    static int init_inodecache(void)
    {	
    	/*创建一块可延展的内存缓冲区，并使用init_once函数初始化，然后赋值给ext2_inode_cachep，kmem_cache_create是内存子系统的函数，第一个参数是这个缓冲区的名字，第二个参数是缓冲区的大小，先设置为一个ext2_inode_info的大小，第三个参数是对齐，第四个参数flag，标志这缓冲区可延展，就是可以向后继续分配，并且可以重新设置大小，第五个参数是初始化函数*/
    	ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
    					     sizeof(struct ext2_inode_info),
    					     0, (SLAB_RECLAIM_ACCOUNT|
    						SLAB_MEM_SPREAD),
    					     init_once, NULL);
    	/*失败了，就返回内存不够的错误*/
    	if (ext2_inode_cachep == NULL)
    		return -ENOMEM;
    	return 0;
    }
    /*销毁上个函数创建的ext2_inode_cachep*/
    static void destroy_inodecache(void)
    {
    	/*内存子系统的内存销毁函数*/
    	kmem_cache_destroy(ext2_inode_cachep);
    }
    /*清理inode的额外的内存资源，一般是指acl结构体*/
    static void ext2_clear_inode(struct inode *inode)
    {
    	/*如果没有配置acl，就不用释放了*/
    #ifdef CONFIG_EXT2_FS_POSIX_ACL
    	struct ext2_inode_info *ei = EXT2_I(inode);
    	/*如果i_acl不是未映射状态就说明需要释放*/
    	if (ei->i_acl && ei->i_acl != EXT2_ACL_NOT_CACHED) {
    		/*之前讲过的函数，释放acl结构体*/
    		posix_acl_release(ei->i_acl);
    		/*标记为未映射*/
    		ei->i_acl = EXT2_ACL_NOT_CACHED;
    	}
    	/*如果i_default_acl不是未映射状态就说明需要释放*/
    	if (ei->i_default_acl && ei->i_default_acl != EXT2_ACL_NOT_CACHED) {
    		/*之前讲过的函数，释放acl结构体*/
    		posix_acl_release(ei->i_default_acl);
    		/*标记为未映射*/
    		ei->i_default_acl = EXT2_ACL_NOT_CACHED;
    	}
    #endif
    }
    /*得到文件系统的挂载选项，存放在seq里*/
    static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
    {
    	/*先得到超级块的内存的信息结构体，大部分信息都在这个结构体里放着*/
    	struct ext2_sb_info *sbi = EXT2_SB(vfs->mnt_sb);
    	/*EXT2_MOUNT_GRPID这个标志代表着在目录里创建文件要设置这个文件的组为这个目录的*/
    	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;
    }
    /*配额的操作函数*/
    #ifdef CONFIG_QUOTA
    static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data, size_t len, loff_t off);
    static ssize_t ext2_quota_write(struct super_block *sb, int type, const char *data, size_t len, loff_t off);
    #endif
    /*超级块的操作函数集合*/
    static const struct super_operations ext2_sops = {
    	.alloc_inode	= ext2_alloc_inode,
    	.destroy_inode	= ext2_destroy_inode,
    	.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,
    	.clear_inode	= ext2_clear_inode,
    	.show_options	= ext2_show_options,
    #ifdef CONFIG_QUOTA
    	.quota_read	= ext2_quota_read,
    	.quota_write	= ext2_quota_write,
    #endif
    };
    /*用在nfs和ext2交流上，sb是ext2的超级块，vobjp是一个内存块，第一个是inode号码，第二个是ext2版本号，返回文件的dentry结构体*/
    static struct dentry *ext2_get_dentry(struct super_block *sb, void *vobjp)
    {
    	__u32 *objp = vobjp;
    	/*inode编号*/
    	unsigned long ino = objp[0];
    	/*ext2版本号*/
    	__u32 generation = objp[1];
    	struct inode *inode;
    	struct dentry *result;
    	/*检查inode编号是不是合法*/
    	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);
    
    
    	/* 根据inode编号获得inode结构体*/
    	inode = iget(sb, ino);
    	/*如果没得到，说明内存不足*/
    	if (inode == NULL)
    		return ERR_PTR(-ENOMEM);
    	/*判断inode是不是合法，另外检查ext2的版本你是不是和要求的一致*/
    	if (is_bad_inode(inode) ||
    	    (generation && inode->i_generation != generation)) {
    		iput(inode);
    		return ERR_PTR(-ESTALE);
    	}
    	/* 根据获得的inode来找dentry*/
    	/*根据inode分配一个dentry结构体*/
    	result = d_alloc_anon(inode);
    	if (!result) {
    		iput(inode);
    		return ERR_PTR(-ENOMEM);
    	}
    	return result;
    }
    
    
    /* nfs文件系统与操作系统进行交流的操作函数集合 */
    static struct export_operations ext2_export_ops = {
    	/*找到一个给定目录的父目录*/
    	.get_parent = ext2_get_parent,
    	/*返回一个文件的dentry*/
    	.get_dentry = ext2_get_dentry,
    };
    /*获得超级块块号，参数data是挂载文件系统的选项*/
    static unsigned long get_sb_block(void **data)
    {
    	unsigned long 	sb_block;
    	/*先获得选项字符串*/
    	char 		*options = (char *) *data;
    	/*检验字符串是不是sb=开头的，不是就说明错了*/
    	if (!options || strncmp(options, "sb=", 3) != 0)
    		return 1;	/* Default location */
    	/*继续看后边的*/
    	options += 3;
    	/*sb_block是从参数得到超级块块号*/
    	sb_block = simple_strtoul(options, &options, 0);
    	/*后边没了，也不对*/
    	if (*options && *options != ',') {
    		printk("EXT2-fs: Invalid sb specification: %s\n",
    		       (char *) *data);
    		return 1;
    	}
    	if (*options == ',')
    		options++;
    	*data = (void *) options;
    	return sb_block;
    }
    /*文件系统的各种选项*/
    enum {
    	Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
    	Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic,
    	Opt_err_ro, Opt_nouid32, Opt_nocheck, Opt_debug,
    	Opt_oldalloc, Opt_orlov, Opt_nobh, Opt_user_xattr, Opt_nouser_xattr,
    	Opt_acl, Opt_noacl, Opt_xip, Opt_ignore, Opt_err, Opt_quota,
    	Opt_usrquota, Opt_grpquota
    };
    /*文件系统的选项和对应的参数字符串*/
    static match_table_t tokens = {
    	{Opt_bsd_df, "bsddf"},
    	{Opt_minix_df, "minixdf"},
    	{Opt_grpid, "grpid"},
    	{Opt_grpid, "bsdgroups"},
    	{Opt_nogrpid, "nogrpid"},
    	{Opt_nogrpid, "sysvgroups"},
    	{Opt_resgid, "resgid=%u"},
    	{Opt_resuid, "resuid=%u"},
    	{Opt_sb, "sb=%u"},
    	{Opt_err_cont, "errors=continue"},
    	{Opt_err_panic, "errors=panic"},
    	{Opt_err_ro, "errors=remount-ro"},
    	{Opt_nouid32, "nouid32"},
    	{Opt_nocheck, "check=none"},
    	{Opt_nocheck, "nocheck"},
    	{Opt_debug, "debug"},
    	{Opt_oldalloc, "oldalloc"},
    	{Opt_orlov, "orlov"},
    	{Opt_nobh, "nobh"},
    	{Opt_user_xattr, "user_xattr"},
    	{Opt_nouser_xattr, "nouser_xattr"},
    	{Opt_acl, "acl"},
    	{Opt_noacl, "noacl"},
    	{Opt_xip, "xip"},
    	{Opt_grpquota, "grpquota"},
    	{Opt_ignore, "noquota"},
    	{Opt_quota, "quota"},
    	{Opt_usrquota, "usrquota"},
    	{Opt_err, NULL}
    };
    /*转化参数字符串，变成ext2_sb_info结构体上相应的位*/
    static int parse_options (char * options,
    			  struct ext2_sb_info *sbi)
    {
    	char * p;
    	substring_t args[MAX_OPT_ARGS];
    	int option;
    	/*字符串不可以是NULL*/
    	if (!options)
    		return 1;
    	/*大循环，一个一个转换字符串为ext2_sb_info的flag，每次读取逗号之间的*/
    	while ((p = strsep (&options, ",")) != NULL) {
    		int token;
    		/*空的，读下一个*/
    		if (!*p)
    			continue;
    		/*在tokens数组里寻找和p指针指向的字符串选项匹配的选项*/
    		token = match_token(p, tokens, args);
    		/*在ext2_sb_info的相应位上设置*/
    		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:
    			printk("EXT2 (no)user_xattr options not supported\n");
    			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:
    			printk("EXT2 (no)acl options not supported\n");
    			break;
    #endif
    		case Opt_xip:
    #ifdef CONFIG_EXT2_FS_XIP
    			set_opt (sbi->s_mount_opt, XIP);
    #else
    			printk("EXT2 xip option not supported\n");
    #endif
    			break;
    
    
    #if defined(CONFIG_QUOTA)
    		case Opt_quota:
    		case Opt_usrquota:
    			set_opt(sbi->s_mount_opt, USRQUOTA);
    			break;
    
    
    		case Opt_grpquota:
    			set_opt(sbi->s_mount_opt, GRPQUOTA);
    			break;
    #else
    		case Opt_quota:
    		case Opt_usrquota:
    		case Opt_grpquota:
    			printk(KERN_ERR
    				"EXT2-fs: quota operations not supported.\n");
    
    
    			break;
    #endif
    
    
    		case Opt_ignore:
    			break;
    		default:
    			return 0;
    		}
    	}
    	return 1;
    }
    /*ext2的初始化超级块，read_only标志文件系统是不是只读挂载*/
    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;
    	/*合法位没有置位，说明文件系统没有经过检查，应当检查一下*/
    	if (!(sbi->s_mount_state & EXT2_VALID_FS))
    		printk ("EXT2-fs warning: mounting unchecked fs, "
    			"running e2fsck is recommended\n");
    	/*如果挂在的时候有错误，打印信息*/
    	else if ((sbi->s_mount_state & EXT2_ERROR_FS))
    		printk ("EXT2-fs warning: mounting fs with errors, "
    			"running e2fsck is recommended\n");
    	/*文件系统最大挂载次数大于等于0，并且当前已经挂载超过最大次数了，打印警告信息*/
    	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) <= get_seconds()))
    		printk ("EXT2-fs warning: checktime reached, "
    			"running e2fsck is recommended\n");
    	/*如果文件系统的最大挂载次数字段为0，设置这个变量为缺省的EXT2_DFL_MAX_MNT_COUNT*/
    	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);
    	return res;
    }
    /*ext2文件系统检查组描述符*/
    static int ext2_check_descriptors (struct super_block * sb)
    {
    	int i;
    	int desc_block = 0;
    	struct ext2_sb_info *sbi = EXT2_SB(sb);
    	/*第一个数据块块号*/
    	unsigned long first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
    	unsigned long last_block;
    	struct ext2_group_desc * gdp = NULL;
    
    
    	ext2_debug ("Checking group descriptors");
    	/*遍历每一个组*/
    	for (i = 0; i < sbi->s_groups_count; i++)
    	{
    		/*判断当前遍历是不是到了最后一个组*/
    		if (i == sbi->s_groups_count - 1)
    			/*如果到了最后一个组，last_block指向最后一个块，因为最后一组可能由于边界的原因不是和之前的组有一样的块数目*/
    			last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
    		else
    			/*last_block是本组最后一个块的块号*/
    			last_block = first_block +
    				(EXT2_BLOCKS_PER_GROUP(sb) - 1);
    		/*组描述符是放在连续的块上的，一个块有若干个描述符，如果当前组过了一个块，就使得gdp新的描述符块缓冲区，因为每一个块是对应一个缓冲区*/
    		if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)
    			gdp = (struct ext2_group_desc *) sbi->s_group_desc[desc_block++]->b_data;
    		/*判断组描述符的块位图编号是不是合法*/
    		if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
    		    le32_to_cpu(gdp->bg_block_bitmap) > last_block)
    		{
    			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;
    		}
    		/*inode位图的块编号是不是合法*/
    		if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
    		    le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
    		{
    			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;
    		}
    		/*判断inodetable的块编号是不是合法*/
    		if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
    		    le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group >
    		    last_block)
    		{
    			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;
    		}
    		/*如果都合法，说明这个组描述符是正确的，我们去找下一个组，first_block指向下一个组的第一个块的块号*/
    		first_block += EXT2_BLOCKS_PER_GROUP(sb);
    		/*组描述符指针指向下一个*/
    		gdp++;
    	}
    	return 1;
    }
    
    
    /* 返回ext2文件系统的最大文件大小，因为ext2支持三重间接连接块 */
    static loff_t ext2_max_size(int bits)
    {
    	/*res先赋值为直接块的数目*/
    	loff_t res = EXT2_NDIR_BLOCKS;
    	/*文件大小上限，不超过32位大小限制*/
    	const loff_t upper_limit = 0x1ff7fffd000LL;
    	/*一级间接块大小*/
    	res += 1LL << (bits-2);
    	/*二级间接块大小*/
    	res += 1LL << (2*(bits-2));
    	/*三级间接块大小*/
    	res += 1LL << (3*(bits-2));
    	res <<= bits;
    	/*超过最大限制，修改下*/
    	if (res > upper_limit)
    		res = upper_limit;
    	return res;
    }
    
    
    static unsigned long descriptor_loc(struct super_block *sb,
    				    unsigned long logic_sb_block,
    				    int nr)
    {
    	struct ext2_sb_info *sbi = EXT2_SB(sb);
    	unsigned long bg, first_data_block, first_meta_bg;
    	int has_super = 0;
    	/*文件系统的第一个数据块的块号*/
    	first_data_block = le32_to_cpu(sbi->s_es->s_first_data_block);
    	/*第一个处理块组*/
    	first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
    
    
    	if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_META_BG) ||
    	    nr < first_meta_bg)
    		return (logic_sb_block + nr + 1);
    	bg = sbi->s_desc_per_block * nr;
    	/*如果这个块组有超级块*/
    	if (ext2_bg_has_super(sb, bg))
    		has_super = 1;
    	return (first_data_block + has_super + (bg * sbi->s_blocks_per_group));
    }
    /*ext2的填充超级块的函数*/
    static int ext2_fill_super(struct super_block *sb, void *data, int silent)
    {
    	struct buffer_head * bh;
    	struct ext2_sb_info * sbi;
    	struct ext2_super_block * es;
    	struct inode *root;
    	unsigned long block;
    	/*之前讲过的函数，从data的字符串参数中获得超级块的块号*/
    	unsigned long sb_block = get_sb_block(&data);
    	unsigned long logic_sb_block;
    	unsigned long offset = 0;
    	unsigned long def_mount_opts;
    	int blocksize = BLOCK_SIZE;
    	int db_count;
    	int i, j;
    	__le32 features;
    	/*分配超级块在内存的信息结构体ext2_sb_info*/
    	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
    	if (!sbi)
    		return -ENOMEM;
    	/*指向这个结构体*/
    	sb->s_fs_info = sbi;
    
    
    	/* 看一下当前的设备的块大小，使用作为文件系统的块大小 */
    	blocksize = sb_min_blocksize(sb, BLOCK_SIZE);
    	if (!blocksize) {
    		printk ("EXT2-fs: unable to set blocksize\n");
    		goto failed_sbi;
    	}
    
    
    	/* 如果块大小不一致，那么刚才获得的超级块也不对了 */
    	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");
    		goto failed_sbi;
    	}
    	/* 使用ext2_super_block指针es指向ext2的超级块 */
    	es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
    	sbi->s_es = es;
    	/*根据读取到的超级块信息填充evfs层的文件系统超级块结构体*/
    	sb->s_magic = le16_to_cpu(es->s_magic);
    	/*魔数如果不是ext2的，说明不是ext2文件系统，直接退出吧*/
    	if (sb->s_magic != EXT2_SUPER_MAGIC)
    		goto cantfind_ext2;
    
    
    	/* 设置sbi结构体，在我们转化挂载选项的之前，先设置为缺省值*/
    	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
    	/*调试选项，用户id和组id，*/
    	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
    	/*是不是支持acl*/
    #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_RO)
    		set_opt(sbi->s_mount_opt, ERRORS_RO);
    	else
    		set_opt(sbi->s_mount_opt, ERRORS_CONT);
    	/*保留uid和gid*/
    	sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
    	sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
    	/*转化选项并设置*/
    	if (!parse_options ((char *) data, sbi))
    		goto failed_mount;
    	/*acl转化*/
    	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); 
    	/*修改级别和feature是不是适合*/
    	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");
    	/*选项检查*/
    	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;
    	}
    	/*如果文件系统不是只读挂载，且feature字段不支持，返回挂载失败*/
    	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;
    	}
    	/*取到ext2_super_block中保存的blocksize */
    	blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
    	/*片内执行的设备的话，实际的块大小和我们猜想的不一致，就不支持*/
    	if ((ext2_use_xip(sb)) && ((blocksize != PAGE_SIZE) ||
    				  (sb->s_blocksize != blocksize))) {
    		if (!silent)
    			printk("XIP: Unsupported blocksize\n");
    		goto failed_mount;
    	}
    
    
    	/* 如果读取到的真实的块大小不匹配的话 */
    	if (sb->s_blocksize != blocksize) {
    		brelse(bh);
    		/*先设置块大小，如果失败了，说明设置的快大小太小*/
    		if (!sb_set_blocksize(sb, blocksize)) {
    			printk(KERN_ERR "EXT2-fs: blocksize too small for device.\n");
    			goto failed_sbi;
    		}
    		/*根据新的块大小重新计算超级块号和偏移*/
    		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_sbi;
    		}
    		/*得到ext2_super_block结构体，并指向*/
    		es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
    		sbi->s_es = es;
    		if (es->s_magic != cpu_to_le16(EXT2_SUPER_MAGIC)) {
    			printk ("EXT2-fs: Magic mismatch, very weird !\n");
    			goto failed_mount;
    		}
    	}
    	/*继续用ext2_super_block中的内容来填充ext2_sb_info*/
    	/*文件的最大字节数*/
    	sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);
    	/*根据修改级别的不同，inode的大小和开始编号不一样*/
    	if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
    		sbi->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
    		sbi->s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
    	} else {
    		sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
    		sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
    		if ((sbi->s_inode_size < EXT2_GOOD_OLD_INODE_SIZE) ||
    		    (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
    		    (sbi->s_inode_size > blocksize)) {
    			printk ("EXT2-fs: unsupported inode size: %d\n",
    				sbi->s_inode_size);
    			goto failed_mount;
    		}
    	}
    	/*碎片的信息填充*/
    	sbi->s_frag_size = EXT2_MIN_FRAG_SIZE <<
    				   le32_to_cpu(es->s_log_frag_size);
    	if (sbi->s_frag_size == 0)
    		goto cantfind_ext2;
    	sbi->s_frags_per_block = sb->s_blocksize / sbi->s_frag_size;
    	/*组的数据块数目，碎片数目，inode数目*/
    	sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
    	sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
    	sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
    
    
    	if (EXT2_INODE_SIZE(sb) == 0)
    		goto cantfind_ext2;
    	/*每块的inode数*/
    	sbi->s_inodes_per_block = sb->s_blocksize / EXT2_INODE_SIZE(sb);
    	if (sbi->s_inodes_per_block == 0 || sbi->s_inodes_per_group == 0)
    		goto cantfind_ext2;
    	/*每组的inodetable块数目*/
    	sbi->s_itb_per_group = sbi->s_inodes_per_group /
    					sbi->s_inodes_per_block;
    	/*每块的描述符数目*/
    	sbi->s_desc_per_block = sb->s_blocksize /
    					sizeof (struct ext2_group_desc);
    	/*超级块缓冲区*/
    	sbi->s_sbh = bh;
    	/*挂载状态*/
    	sbi->s_mount_state = le16_to_cpu(es->s_state);
    	/*每块的指针数目的二进制位数*/
    	sbi->s_addr_per_block_bits =
    		ilog2 (EXT2_ADDR_PER_BLOCK(sb));
    	/*每块的组描述符数目的二进制位数*/
    	sbi->s_desc_per_block_bits =
    		ilog2 (EXT2_DESC_PER_BLOCK(sb));
    
    
    	if (sb->s_magic != EXT2_SUPER_MAGIC)
    		goto cantfind_ext2;
    	/*设备的块大小是不是支持*/
    	if (sb->s_blocksize != bh->b_size) {
    		if (!silent)
    			printk ("VFS: Unsupported blocksize on dev "
    				"%s.\n", sb->s_id);
    		goto failed_mount;
    	}
    	/*碎片大小是不是不等于块大小*/
    	if (sb->s_blocksize != sbi->s_frag_size) {
    		printk ("EXT2-fs: fragsize %lu != blocksize %lu (not supported yet)\n",
    			sbi->s_frag_size, sb->s_blocksize);
    		goto failed_mount;
    	}
    	/*每组的块数目必须大于8*/
    	if (sbi->s_blocks_per_group > sb->s_blocksize * 8) {
    		printk ("EXT2-fs: #blocks per group too big: %lu\n",
    			sbi->s_blocks_per_group);
    		goto failed_mount;
    	}
    	/*每组的碎片必须多于8块*/
    	if (sbi->s_frags_per_group > sb->s_blocksize * 8) {
    		printk ("EXT2-fs: #fragments per group too big: %lu\n",
    			sbi->s_frags_per_group);
    		goto failed_mount;
    	}
    	/*inode必须多于8块*/
    	if (sbi->s_inodes_per_group > sb->s_blocksize * 8) {
    		printk ("EXT2-fs: #inodes per group too big: %lu\n",
    			sbi->s_inodes_per_group);
    		goto failed_mount;
    	}
    
    
    	if (EXT2_BLOCKS_PER_GROUP(sb) == 0)
    		goto cantfind_ext2;
    	/*记录组的数目*/
     	sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
     				le32_to_cpu(es->s_first_data_block) - 1)
     					/ EXT2_BLOCKS_PER_GROUP(sb)) + 1;
    	db_count = (sbi->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
    		   EXT2_DESC_PER_BLOCK(sb);
    	/*为组描述符分配空间*/
    	sbi->s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
    	if (sbi->s_group_desc == NULL) {
    		printk ("EXT2-fs: not enough memory\n");
    		goto failed_mount;
    	}
    	bgl_lock_init(&sbi->s_blockgroup_lock);
    	/*文件系统的负载分配空间*/
    	sbi->s_debts = kmalloc(sbi->s_groups_count * sizeof(*sbi->s_debts),
    			       GFP_KERNEL);
    	if (!sbi->s_debts) {
    		printk ("EXT2-fs: not enough memory\n");
    		goto failed_mount_group_desc;
    	}
    	memset(sbi->s_debts, 0, sbi->s_groups_count * sizeof(*sbi->s_debts));
    	/*初始化每一组的负载的值，并读入组描述符*/
    	for (i = 0; i < db_count; i++) {
    		block = descriptor_loc(sb, logic_sb_block, i);
    		sbi->s_group_desc[i] = sb_bread(sb, block);
    		if (!sbi->s_group_desc[i]) {
    			for (j = 0; j < i; j++)
    				brelse (sbi->s_group_desc[j]);
    			printk ("EXT2-fs: unable to read group descriptors\n");
    			goto failed_mount_group_desc;
    		}
    	}
    	if (!ext2_check_descriptors (sb)) {
    		printk ("EXT2-fs: group descriptors corrupted!\n");
    		goto failed_mount2;
    	}
    	sbi->s_gdb_count = db_count;
    	get_random_bytes(&sbi->s_next_generation, sizeof(u32));
    	spin_lock_init(&sbi->s_next_gen_lock);
    	/*初始化percpu相关的几个变量*/
    	percpu_counter_init(&sbi->s_freeblocks_counter,
    				ext2_count_free_blocks(sb));
    	percpu_counter_init(&sbi->s_freeinodes_counter,
    				ext2_count_free_inodes(sb));
    	percpu_counter_init(&sbi->s_dirs_counter,
    				ext2_count_dirs(sb));
    	/*初始化ok*/
    	sb->s_op = &ext2_sops;
    	sb->s_export_op = &ext2_export_ops;
    	sb->s_xattr = ext2_xattr_handlers;
    	/*开始读入根节点的inode*/
    	root = iget(sb, EXT2_ROOT_INO);
    	sb->s_root = d_alloc_root(root);
    	/*检查读入的inode是不是有问题*/
    	if (!sb->s_root) {
    		iput(root);
    		printk(KERN_ERR "EXT2-fs: get root inode failed\n");
    		goto failed_mount3;
    	}
    	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
    		dput(sb->s_root);
    		sb->s_root = NULL;
    		printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");
    		goto failed_mount3;
    	}
    	if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
    		ext2_warning(sb, __FUNCTION__,
    			"mounting ext3 filesystem as ext2");
    	/*检查超级块，检查完写入设备*/
    	ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
    	return 0;
    
    
    cantfind_ext2:
    	if (!silent)
    		printk("VFS: Can't find an ext2 filesystem on dev %s.\n",
    		       sb->s_id);
    	goto failed_mount;
    failed_mount3:
    	percpu_counter_destroy(&sbi->s_freeblocks_counter);
    	percpu_counter_destroy(&sbi->s_freeinodes_counter);
    	percpu_counter_destroy(&sbi->s_dirs_counter);
    failed_mount2:
    	for (i = 0; i < db_count; i++)
    		brelse(sbi->s_group_desc[i]);
    failed_mount_group_desc:
    	kfree(sbi->s_group_desc);
    	kfree(sbi->s_debts);
    failed_mount:
    	brelse(bh);
    failed_sbi:
    	sb->s_fs_info = NULL;
    	kfree(sbi);
    	return -EINVAL;
    }
    /*提交超级块的修改*/
    static void ext2_commit_super (struct super_block * sb,
    			       struct ext2_super_block * es)
    {
    	/*记录修改时间，标记超级块脏*/
    	es->s_wtime = cpu_to_le32(get_seconds());
    	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
    	sb->s_dirt = 0;
    }
    /*同步超级块和硬盘上的*/
    static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es)
    {
    	/*更新空闲块和inode的信息，以及修改时间*/
    	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_wtime = cpu_to_le32(get_seconds());
    	/*标记脏，然后同步*/
    	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
    	sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
    	/*同步ok，标记不脏*/
    	sb->s_dirt = 0;
    }
    
    
    /*ext2写入超级块结构体到硬盘上 */
    void ext2_write_super (struct super_block * sb)
    {
    	struct ext2_super_block * es;
    	lock_kernel();
    	/*只读挂载的是不可以写的*/
    	if (!(sb->s_flags & MS_RDONLY)) {
    		/*得到ext2_super_block结构体*/
    		es = EXT2_SB(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_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();
    }
    /*ext2的重新挂载操作*/
    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;
    
    
    	/* 存储原先挂载的选项 */
    	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;
    
    
    	/* 转化选项 */
    	if (!parse_options (data, sbi)) {
    		err = -EINVAL;
    		goto restore_opts;
    	}
    	/*原来的acl的flag转化为sb指针结构体上的flag*/
    	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
    		((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
    	/*看看块设备是不是支持xip，如果不支持，EXT2_MOUNT_XIP位就取消掉*/
    	ext2_xip_verify_sb(sb); 
    	/*如果使用了xip块大小就必须等于页大小*/
    	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, __FUNCTION__, "busy inodes while remounting "\
    			     "xip remain in cache (no functional problem)");
    	/*都是只读挂载的时候，就可以结束了*/
    	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
    		return 0;
    	/*新的flag是只读的*/
    	if (*flags & MS_RDONLY) {
    		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
    		    !(sbi->s_mount_state & EXT2_VALID_FS))
    			return 0;
    		/* 把原来的读写挂载变成只读挂载 */
    		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;
    		}
    		/* 把一个只读挂载变成读写挂载 */
    		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);
    	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;
    	return err;
    }
    /*把ext2的状态存到kstatfs指针里*/
    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;
    	unsigned long overhead;
    	int i;
    	u64 fsid;
    	/*先计算第一个数据块前边的块数目，如果有宏，就是0*/
    	if (test_opt (sb, MINIX_DF))
    		overhead = 0;
    	else {
    		overhead = le32_to_cpu(es->s_first_data_block);
    
    
    		/* 增加前边的每组的超级块和描述符 */
    		for (i = 0; i < sbi->s_groups_count; i++)
    			overhead += ext2_bg_has_super(sb, i) +
    				ext2_bg_num_gdb(sb, i);
    
    
    		/* inode位图，块位图，inodetable */
    		overhead += (sbi->s_groups_count *
    			     (2 + sbi->s_itb_per_group));
    	}
    	/*填充buf，文件系统魔数，块大小，块数，空闲数据块数目*/
    	buf->f_type = EXT2_SUPER_MAGIC;
    	buf->f_bsize = sb->s_blocksize;
    	buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
    	buf->f_bfree = ext2_count_free_blocks(sb);
    	/*除去保留块的空闲块数*/
    	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;
    	/*inode数目*/
    	buf->f_files = le32_to_cpu(es->s_inodes_count);
    	/*空闲inode*/
    	buf->f_ffree = ext2_count_free_inodes(sb);
    	/*最大名称长度*/
    	buf->f_namelen = EXT2_NAME_LEN;
    	/*fsuid*/
    	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_get_sb(struct file_system_type *fs_type,
    	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
    {
    	return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super, mnt);
    }
    /*配额的函数*/
    #ifdef CONFIG_QUOTA
    
    
    /* 从配额文件里读取数据 */
    static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data,
    			       size_t len, loff_t off)
    {
    	/*得到硬盘上的配额文件的inode*/
    	struct inode *inode = sb_dqopt(sb)->files[type];
    	sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
    	int err = 0;
    	int offset = off & (sb->s_blocksize - 1);
    	int tocopy;
    	size_t toread;
    	struct buffer_head tmp_bh;
    	struct buffer_head *bh;
    	/*得到文件的大小*/
    	loff_t i_size = i_size_read(inode);
    	/*偏移超过文件大小，出错了*/
    	if (off > i_size)
    		return 0;
    	/*读的长度超出文件尾部，也不可能*/
    	if (off+len > i_size)
    		len = i_size-off;
    	toread = len;
    	while (toread > 0) {
    		/*将要读的长度*/
    		tocopy = sb->s_blocksize - offset < toread ?
    				sb->s_blocksize - offset : toread;
    
    
    		tmp_bh.b_state = 0;
    		/*读取文件内容*/
    		err = ext2_get_block(inode, blk, &tmp_bh, 0);
    		if (err)
    			return err;
    		/*如果没有映射，赋值为0*/
    		if (!buffer_mapped(&tmp_bh))	/* 坑? */
    			memset(data, 0, tocopy);
    		else {
    			bh = sb_bread(sb, tmp_bh.b_blocknr);
    			if (!bh)
    				return -EIO;
    			memcpy(data, bh->b_data+offset, tocopy);
    			brelse(bh);
    		}
    		offset = 0;
    		toread -= tocopy;
    		data += tocopy;
    		blk++;
    	}
    	return len;
    }
    
    
    /* 写数据到配额文件 */
    static ssize_t ext2_quota_write(struct super_block *sb, int type,
    				const char *data, size_t len, loff_t off)
    {
    	struct inode *inode = sb_dqopt(sb)->files[type];
    	sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
    	int err = 0;
    	int offset = off & (sb->s_blocksize - 1);
    	int tocopy;
    	size_t towrite = len;
    	struct buffer_head tmp_bh;
    	struct buffer_head *bh;
    
    
    	mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
    	/*循环写入*/
    	while (towrite > 0) {
    		/*先写的数据长度*/
    		tocopy = sb->s_blocksize - offset < towrite ?
    				sb->s_blocksize - offset : towrite;
    
    
    		tmp_bh.b_state = 0;
    		/*得到要写入的文件*/
    		err = ext2_get_block(inode, blk, &tmp_bh, 1);
    		if (err)
    			goto out;
    		/*得到缓冲区*/
    		if (offset || tocopy != EXT2_BLOCK_SIZE(sb))
    			bh = sb_bread(sb, tmp_bh.b_blocknr);
    		else
    			bh = sb_getblk(sb, tmp_bh.b_blocknr);
    		if (!bh) {
    			err = -EIO;
    			goto out;
    		}
    		lock_buffer(bh);
    		/*复制数据到文件缓冲区*/
    		memcpy(bh->b_data+offset, data, tocopy);
    		/*清空缓冲区，写入到设备上*/
    		flush_dcache_page(bh->b_page);
    		set_buffer_uptodate(bh);
    		mark_buffer_dirty(bh);
    		unlock_buffer(bh);
    		brelse(bh);
    		/*更新这些变量*/
    		offset = 0;
    		towrite -= tocopy;
    		data += tocopy;
    		blk++;
    	}
    out:
    	if (len == towrite)
    		return err;
    	if (inode->i_size < off+len-towrite)
    		i_size_write(inode, off+len-towrite);
    	inode->i_version++;
    	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
    	mark_inode_dirty(inode);
    	mutex_unlock(&inode->i_mutex);
    	return len - towrite;
    }
    
    
    #endif
    /*ext2文件系统类型结构体*/
    static struct file_system_type ext2_fs_type = {
    	.owner		= THIS_MODULE,
    	.name		= "ext2",
    	.get_sb		= ext2_get_sb,
    	.kill_sb	= kill_block_super,
    	.fs_flags	= FS_REQUIRES_DEV,
    };
    /*ext2的模块初始化*/
    static int __init init_ext2_fs(void)
    {
    	/*初始化属性*/
    	int err = init_ext2_xattr();
    	if (err)
    		return err;
    	/*初始化inode缓存*/
    	err = init_inodecache();
    	if (err)
    		goto out1;
    		/*登记ext2*/
            err = register_filesystem(&ext2_fs_type);
    	if (err)
    		goto out;
    	return 0;
    out:
    	destroy_inodecache();
    out1:
    	exit_ext2_xattr();
    	return err;
    }
    /*ext2的模块清理*/
    static void __exit exit_ext2_fs(void)
    {
    	/*注销ext2*/
    	unregister_filesystem(&ext2_fs_type);
    	destroy_inodecache();
    	exit_ext2_xattr();
    }
    
    
    module_init(init_ext2_fs)
    module_exit(exit_ext2_fs)