From fc68fc81042df576ab2efabd3066649ae90f0e50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E5=93=B2=E6=88=90?= <11314483+zhou-zhecheng@user.noreply.gitee.com> Date: Fri, 13 Oct 2023 02:54:31 +0000 Subject: [PATCH] add src/views/superblock. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 周哲成 <11314483+zhou-zhecheng@user.noreply.gitee.com> --- src/views/superblock | 1500 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1500 insertions(+) create mode 100644 src/views/superblock diff --git a/src/views/superblock b/src/views/superblock new file mode 100644 index 0000000..854ae88 --- /dev/null +++ b/src/views/superblock @@ -0,0 +1,1500 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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来解决*/ + /* 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. + */ +} +/*释放正在使用的超级块*/ +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的slab缓冲区*/ +static struct kmem_cache * ext2_inode_cachep; + /*ext2分配一个空的inode，先分配ext2_inode_info，再返回其中的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->i_block_alloc_info = NULL; + 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的指针,foo为ext2_inode_info*/ +static void init_once(struct kmem_cache * cachep, void *foo) +{ /*先转化获得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*/ + mutex_init(&ei->truncate_mutex); + 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); + /*失败了，就返回内存不够的错误*/ + 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) +{ + struct ext2_block_alloc_info *rsv = EXT2_I(inode)->i_block_alloc_info; + /*如果没有配置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 + ext2_discard_reservation(inode); + EXT2_I(inode)->i_block_alloc_info = NULL; + if (unlikely(rsv)) + kfree(rsv); +} +/*得到文件系统的挂载选项，存放在seq里*/ +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_CONT)) { + int def_errors = le16_to_cpu(es->s_errors); + + if (def_errors == EXT2_ERRORS_PANIC || + def_errors == EXT2_ERRORS_RO) { + seq_puts(seq, ",errors=continue"); + } + } + if (test_opt(sb, ERRORS_RO)) + seq_puts(seq, ",errors=remount-ro"); + 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 + + 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, + .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 inode *ext2_nfs_get_inode(struct super_block *sb, + u64 ino, u32 generation) +{ + struct inode *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); + + /* 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); + } + return inode; +} + +static struct dentry *ext2_fh_to_dentry(struct super_block *sb, struct fid *fid, + int fh_len, int fh_type) +{ + return generic_fh_to_dentry(sb, fid, fh_len, fh_type, + ext2_nfs_get_inode); +} + +static struct dentry *ext2_fh_to_parent(struct super_block *sb, struct fid *fid, + int fh_len, int fh_type) +{ + return generic_fh_to_parent(sb, fid, fh_len, fh_type, + ext2_nfs_get_inode); +} + +/* Yes, most of these are left as NULL!! + * A NULL value implies the default, which works with ext2-like file + * systems, but can be improved upon. + * Currently only get_parent is required. + *//* nfs文件系统与操作系统进行交流的操作函数集合 */ +static const struct export_operations ext2_export_ops = { + .fh_to_dentry = ext2_fh_to_dentry, + .fh_to_parent = ext2_fh_to_parent, + .get_parent = ext2_get_parent, +}; + /*获得超级块块号，参数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, Opt_reservation, Opt_noreservation +}; + /*文件系统的选项和对应的参数字符串*/ +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_reservation, "reservation"}, + {Opt_noreservation, "noreservation"}, + {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_reservation: + set_opt(sbi->s_mount_opt, RESERVATION); + printk("reservations ON\n"); + break; + case Opt_noreservation: + clear_opt(sbi->s_mount_opt, RESERVATION); + printk("reservations OFF\n"); + break; + 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 - 1 >//s_itb_per_group为inode table占的块数 + 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; +} + +/* + * 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. + *//* 返回ext2文件系统的最大文件大小，因为ext2支持三重间接连接块 */ +static loff_t ext2_max_size(int bits) +{ /*res先赋值为直接块的数目*/ + loff_t res = EXT2_NDIR_BLOCKS; + /* This constant is calculated to be the largest file size for a + * dense, 4k-blocksize file such that the total number of + * sectors in the file, including data and all indirect blocks, + * does not exceed 2^32. */ + const loff_t upper_limit = 0x1ff7fffd000LL;/*文件大小上限，不超过32位大小限制*/ + /*一级间接块大小*/ + 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; +} +//返回第nr个组描述符的快号 +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));//first_meta_bg块全是存储的描述符 +} + /*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; + int err; + /*分配超级块在内存的信息结构体ext2_sb_info*/ + sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); + if (!sbi) + return -ENOMEM; + sb->s_fs_info = sbi; + sbi->s_sb_block = sb_block; + + /* + * 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 = sb_min_blocksize(sb, BLOCK_SIZE); + if (!blocksize) { + printk ("EXT2-fs: unable to set blocksize\n"); + goto failed_sbi; + } + + /* + * If the superblock doesn't start on a hardware sector boundary, + * calculate the offset. + *//* 如果块大小不一致，那么刚才获得的超级块也不对了 */ + 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; + } + /* + * Note: s_es must be initialized as soon as possible because + * some ext2 macro-instructions depend on its value + *//* 使用ext2_super_block指针es指向缓冲区中ext2的超级块 */ + es = (struct ext2_super_block *) (((char *)bh->b_data) + offset); + sbi->s_es = es;//指向缓冲区中超级快的指针 + /*根据读取到的超级块信息填充vfs层的文件系统超级块结构体*/ + sb->s_magic = le16_to_cpu(es->s_magic); + /*魔数如果不是ext2的，说明不是ext2文件系统，直接退出吧*/ + if (sb->s_magic != EXT2_SUPER_MAGIC) + goto cantfind_ext2; + /* 设置sbi结构体，在我们转化挂载选项的之前，先设置为缺省值*/ + /* Set defaults before we parse the mount options */ + 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); + + set_opt(sbi->s_mount_opt, RESERVATION); + /*转化选项并设置*/ + 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); /* see if bdev supports xip, unset + EXT2_MOUNT_XIP if not */ + /*修改级别和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"); + /* + * 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; + } + /*如果文件系统不是只读挂载，且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 the blocksize doesn't match, re-read the thing.. */ + 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; + } + 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) || + !is_power_of_2(sbi->s_inode_size) || + (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 = kcalloc(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; + } + /*初始化每一组的负载的值，并读入组描述符*/ + for (i = 0; i < db_count; i++) { + block = descriptor_loc(sb, logic_sb_block, i);//定位第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)) {/*ext2文件系统检查组描述符一致性*/ + 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); + + /* per fileystem reservation list head & lock */ + spin_lock_init(&sbi->s_rsv_window_lock); + sbi->s_rsv_window_root = RB_ROOT; + /* + * Add a single, static dummy reservation to the start of the + * reservation window list --- it gives us a placeholder for + * append-at-start-of-list which makes the allocation logic + * _much_ simpler. + */ + sbi->s_rsv_window_head.rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED; + sbi->s_rsv_window_head.rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED; + sbi->s_rsv_window_head.rsv_alloc_hit = 0; + sbi->s_rsv_window_head.rsv_goal_size = 0; + ext2_rsv_window_add(sb, &sbi->s_rsv_window_head); + /*初始化percpu相关的几个变量*/ + err = percpu_counter_init(&sbi->s_freeblocks_counter, + ext2_count_free_blocks(sb)); + if (!err) { + err = percpu_counter_init(&sbi->s_freeinodes_counter, + ext2_count_free_inodes(sb)); + } + if (!err) { + err = percpu_counter_init(&sbi->s_dirs_counter, + ext2_count_dirs(sb)); + } + if (err) { + printk(KERN_ERR "EXT2-fs: insufficient memory\n"); + goto failed_mount3; + } + /*/*初始化ok + * set up enough so that it can read an inode + */ + 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; +} + +/* + * 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. + */ + /*ext2写入超级块结构体到硬盘上 */ +void ext2_write_super (struct super_block * sb) +{ + struct ext2_super_block * es; + lock_kernel(); + /*只读挂载的是不可以写的*/ + if (!(sb->s_flags & MS_RDONLY)) { + es = EXT2_SB(sb)->s_es;/*得到ext2_super_block结构体*/ + /*如果状态是合法的文件系统的话*/ + 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; + /* 存储原先挂载的选项 */ + /* 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. + *//* 转化选项 ，将data中相应选项保存入sbi*/ + 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); /* see if bdev supports xip, unset + EXT2_MOUNT_XIP if not */ + /*如果使用了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; + /* + * 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); + 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;//超级块的磁盘信息 + u64 fsid; + /*先计算第一个数据块前边的块数目，如果有宏，就是0*/ + 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.计算开销（FS结构）。 + 除非块组的数量发生更改，否则这对于给定的文件系统而言是恒定的，因此我们将缓存先前的值， + 直到它改变为止。 + */ + + /* + * 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. + *//* 增加前边的每组的超级块和描述符 为overhead*/ + 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. + *//* inode位图，块位图，inodetable */ + 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，文件系统魔数，块大小，块数，空闲数据块数目*/ + 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);/*inode数目*/ + buf->f_ffree = ext2_count_free_inodes(sb);/*空闲inode*/ + 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) ^/*fsuid*/ + 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 + +/* Read data from quotafile - avoid pagecache and such because we cannot afford + * acquiring the locks... As quota files are never truncated and quota code + * itself serializes the operations (and noone else should touch the files) + * we don't have to be afraid of races *//* 从配额文件里读取数据 */ +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 < 0) + return err; + /*如果没有映射，赋值为0*/ + if (!buffer_mapped(&tmp_bh)) /* A hole? */ + 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; +} + +/* Write to quotafile *//* 写数据到配额文件 */ +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 < 0) + 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; + err = init_inodecache();/*初始化inode缓存*/ + if (err) + goto out1; + err = register_filesystem(&ext2_fs_type);/*登记ext2*/ + 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) +