Lines Matching full:fs
59 #include <fs/ext2fs/fs.h>
60 #include <fs/ext2fs/ext2_mount.h>
61 #include <fs/ext2fs/inode.h>
63 #include <fs/ext2fs/ext2fs.h>
64 #include <fs/ext2fs/ext2_dinode.h>
65 #include <fs/ext2fs/ext2_extern.h>
66 #include <fs/ext2fs/ext2_extents.h>
109 struct ext2fs * es, struct m_ext2fs * fs);
127 struct m_ext2fs *fs; in ext2_mount() local
155 fs = ump->um_e2fs; in ext2_mount()
157 if (fs->e2fs_ronly == 0 && in ext2_mount()
166 if (error == 0 && fs->e2fs_wasvalid && in ext2_mount()
168 fs->e2fs->e2fs_state = in ext2_mount()
169 htole16((le16toh(fs->e2fs->e2fs_state) | in ext2_mount()
173 fs->e2fs_ronly = 1; in ext2_mount()
184 if (fs->e2fs_ronly && !vfs_flagopt(opts, "ro", NULL, 0)) { in ext2_mount()
185 if (ext2_check_sb_compat(fs->e2fs, devvp->v_rdev, 0)) in ext2_mount()
208 if ((le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN) == 0 || in ext2_mount()
209 (le16toh(fs->e2fs->e2fs_state) & E2FS_ERRORS)) { in ext2_mount()
212 "WARNING: %s was not properly dismounted\n", fs->e2fs_fsmnt); in ext2_mount()
216 fs->e2fs_fsmnt); in ext2_mount()
220 fs->e2fs->e2fs_state = in ext2_mount()
221 htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN); in ext2_mount()
223 fs->e2fs_ronly = 0; in ext2_mount()
282 fs = ump->um_e2fs; in ext2_mount()
288 strncpy(fs->e2fs_fsmnt, path, MAXMNTLEN); in ext2_mount()
289 fs->e2fs_fsmnt[MAXMNTLEN - 1] = '\0'; in ext2_mount()
334 ext2_cg_location(struct m_ext2fs *fs, int number) in ext2_cg_location() argument
343 logical_sb = fs->e2fs_bsize > SBLOCKSIZE ? 0 : 1; in ext2_cg_location()
345 if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) || in ext2_cg_location()
346 number < le32toh(fs->e2fs->e3fs_first_meta_bg)) in ext2_cg_location()
349 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) in ext2_cg_location()
350 descpb = fs->e2fs_bsize / sizeof(struct ext2_gd); in ext2_cg_location()
352 descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE; in ext2_cg_location()
356 if (ext2_cg_has_sb(fs, cg)) in ext2_cg_location()
359 return (has_super + cg * (e4fs_daddr_t)EXT2_BLOCKS_PER_GROUP(fs) + in ext2_cg_location()
360 le32toh(fs->e2fs->e2fs_first_dblock)); in ext2_cg_location()
364 ext2_cg_validate(struct m_ext2fs *fs) in ext2_cg_validate() argument
373 first_block = le32toh(fs->e2fs->e2fs_first_dblock); in ext2_cg_validate()
374 last_cg_block = ext2_cg_number_gdb(fs, 0); in ext2_cg_validate()
375 cg_count = fs->e2fs_gcount; in ext2_cg_validate()
377 for (i = 0; i < fs->e2fs_gcount; i++) { in ext2_cg_validate()
378 gd = &fs->e2fs_gd[i]; in ext2_cg_validate()
380 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) || in ext2_cg_validate()
381 i == fs->e2fs_gcount - 1) { in ext2_cg_validate()
382 last_block = fs->e2fs_bcount - 1; in ext2_cg_validate()
385 (EXT2_BLOCKS_PER_GROUP(fs) - 1); in ext2_cg_validate()
388 if ((cg_count == fs->e2fs_gcount) && in ext2_cg_validate()
438 i_tables + fs->e2fs_itpg - 1 > last_block) { in ext2_cg_validate()
444 if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG)) in ext2_cg_validate()
445 first_block += EXT2_BLOCKS_PER_GROUP(fs); in ext2_cg_validate()
457 struct m_ext2fs *fs) in ext2_compute_sb_data() argument
466 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) && in ext2_compute_sb_data()
467 EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) { in ext2_compute_sb_data()
474 ext2_sb_csum_set_seed(fs); in ext2_compute_sb_data()
477 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) { in ext2_compute_sb_data()
478 error = ext2_sb_csum_verify(fs); in ext2_compute_sb_data()
491 fs->e2fs_bshift = EXT2_MIN_BLOCK_LOG_SIZE + le32toh(es->e2fs_log_bsize); in ext2_compute_sb_data()
492 fs->e2fs_bsize = 1U << fs->e2fs_bshift; in ext2_compute_sb_data()
493 fs->e2fs_fsbtodb = le32toh(es->e2fs_log_bsize) + 1; in ext2_compute_sb_data()
494 fs->e2fs_qbmask = fs->e2fs_bsize - 1; in ext2_compute_sb_data()
504 fs->e2fs_fsize = EXT2_MIN_FRAG_SIZE << le32toh(es->e2fs_log_fsize); in ext2_compute_sb_data()
505 if (fs->e2fs_fsize != fs->e2fs_bsize) { in ext2_compute_sb_data()
511 fs->e2fs_fpb = fs->e2fs_bsize / fs->e2fs_fsize; in ext2_compute_sb_data()
514 if (le16toh(es->e2fs_reserved_ngdb) > (fs->e2fs_bsize / 4)) { in ext2_compute_sb_data()
521 fs->e2fs_isize = E2FS_REV0_INODE_SIZE; in ext2_compute_sb_data()
523 fs->e2fs_isize = le16toh(es->e2fs_inode_size); in ext2_compute_sb_data()
537 if (EXT2_INODE_SIZE(fs) < E2FS_REV0_INODE_SIZE || in ext2_compute_sb_data()
538 EXT2_INODE_SIZE(fs) > fs->e2fs_bsize || in ext2_compute_sb_data()
539 (fs->e2fs_isize & (fs->e2fs_isize - 1)) != 0) { in ext2_compute_sb_data()
547 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) && in ext2_compute_sb_data()
554 fs->e2fs_bpg = le32toh(es->e2fs_bpg); in ext2_compute_sb_data()
555 fs->e2fs_fpg = le32toh(es->e2fs_fpg); in ext2_compute_sb_data()
556 if (fs->e2fs_bpg == 0 || fs->e2fs_fpg == 0) { in ext2_compute_sb_data()
560 } else if (fs->e2fs_bpg != fs->e2fs_fpg) { in ext2_compute_sb_data()
566 if (fs->e2fs_bpg != fs->e2fs_bsize * 8) { in ext2_compute_sb_data()
572 fs->e2fs_ipb = fs->e2fs_bsize / EXT2_INODE_SIZE(fs); in ext2_compute_sb_data()
573 if (fs->e2fs_ipb == 0 || in ext2_compute_sb_data()
574 fs->e2fs_ipb > fs->e2fs_bsize / E2FS_REV0_INODE_SIZE) { in ext2_compute_sb_data()
580 fs->e2fs_ipg = le32toh(es->e2fs_ipg); in ext2_compute_sb_data()
581 if (fs->e2fs_ipg < fs->e2fs_ipb || fs->e2fs_ipg > fs->e2fs_bsize * 8) { in ext2_compute_sb_data()
587 fs->e2fs_itpg = fs->e2fs_ipg / fs->e2fs_ipb; in ext2_compute_sb_data()
589 fs->e2fs_bcount = le32toh(es->e2fs_bcount); in ext2_compute_sb_data()
590 fs->e2fs_rbcount = le32toh(es->e2fs_rbcount); in ext2_compute_sb_data()
591 fs->e2fs_fbcount = le32toh(es->e2fs_fbcount); in ext2_compute_sb_data()
592 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) { in ext2_compute_sb_data()
593 fs->e2fs_bcount |= (uint64_t)(le32toh(es->e4fs_bcount_hi)) << 32; in ext2_compute_sb_data()
594 fs->e2fs_rbcount |= (uint64_t)(le32toh(es->e4fs_rbcount_hi)) << 32; in ext2_compute_sb_data()
595 fs->e2fs_fbcount |= (uint64_t)(le32toh(es->e4fs_fbcount_hi)) << 32; in ext2_compute_sb_data()
597 if (fs->e2fs_rbcount > fs->e2fs_bcount || in ext2_compute_sb_data()
598 fs->e2fs_fbcount > fs->e2fs_bcount) { in ext2_compute_sb_data()
604 fs->e2fs_ficount = le32toh(es->e2fs_ficount); in ext2_compute_sb_data()
605 if (fs->e2fs_ficount > le32toh(es->e2fs_icount)) { in ext2_compute_sb_data()
611 if (le32toh(es->e2fs_first_dblock) != (fs->e2fs_bsize > 1024 ? 0 : 1) || in ext2_compute_sb_data()
612 le32toh(es->e2fs_first_dblock) >= fs->e2fs_bcount) { in ext2_compute_sb_data()
618 fs->e2fs_gcount = howmany(fs->e2fs_bcount - in ext2_compute_sb_data()
619 le32toh(es->e2fs_first_dblock), EXT2_BLOCKS_PER_GROUP(fs)); in ext2_compute_sb_data()
620 if (fs->e2fs_gcount > ((uint64_t)1 << 32) - EXT2_DESCS_PER_BLOCK(fs)) { in ext2_compute_sb_data()
627 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_EXTRA_ISIZE) && in ext2_compute_sb_data()
628 EXT2_INODE_SIZE(fs) < sizeof(struct ext2fs_dinode)) { in ext2_compute_sb_data()
636 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) { in ext2_compute_sb_data()
637 e2fs_descpb = fs->e2fs_bsize / E2FS_64BIT_GD_SIZE; in ext2_compute_sb_data()
638 e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount, e2fs_descpb); in ext2_compute_sb_data()
640 e2fs_descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE; in ext2_compute_sb_data()
641 e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount, in ext2_compute_sb_data()
642 fs->e2fs_bsize / sizeof(struct ext2_gd)); in ext2_compute_sb_data()
644 fs->e2fs_gdbcount = howmany(fs->e2fs_gcount, e2fs_descpb); in ext2_compute_sb_data()
645 fs->e2fs_gd = malloc(e2fs_gdbcount_alloc * fs->e2fs_bsize, in ext2_compute_sb_data()
647 fs->e2fs_contigdirs = malloc(fs->e2fs_gcount * in ext2_compute_sb_data()
648 sizeof(*fs->e2fs_contigdirs), M_EXT2MNT, M_WAITOK | M_ZERO); in ext2_compute_sb_data()
650 for (i = 0; i < fs->e2fs_gdbcount; i++) { in ext2_compute_sb_data()
652 fsbtodb(fs, ext2_cg_location(fs, i)), in ext2_compute_sb_data()
653 fs->e2fs_bsize, NOCRED, &bp); in ext2_compute_sb_data()
656 * fs->e2fs_gd and fs->e2fs_contigdirs in ext2_compute_sb_data()
663 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) { in ext2_compute_sb_data()
664 memcpy(&fs->e2fs_gd[ in ext2_compute_sb_data()
665 i * fs->e2fs_bsize / sizeof(struct ext2_gd)], in ext2_compute_sb_data()
666 bp->b_data, fs->e2fs_bsize); in ext2_compute_sb_data()
669 g_count < fs->e2fs_gcount; j++, g_count++) in ext2_compute_sb_data()
670 memcpy(&fs->e2fs_gd[g_count], in ext2_compute_sb_data()
679 error = ext2_cg_validate(fs); in ext2_compute_sb_data()
684 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) || in ext2_compute_sb_data()
685 EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) { in ext2_compute_sb_data()
686 error = ext2_gd_csum_verify(fs, devvp->v_rdev); in ext2_compute_sb_data()
691 fs->e2fs_total_dir = 0; in ext2_compute_sb_data()
692 for (i = 0; i < fs->e2fs_gcount; i++) in ext2_compute_sb_data()
693 fs->e2fs_total_dir += e2fs_gd_get_ndirs(&fs->e2fs_gd[i]); in ext2_compute_sb_data()
696 !EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_LARGEFILE)) in ext2_compute_sb_data()
697 fs->e2fs_maxfilesize = 0x7fffffff; in ext2_compute_sb_data()
699 fs->e2fs_maxfilesize = 0xffffffffffff; in ext2_compute_sb_data()
700 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE)) in ext2_compute_sb_data()
701 fs->e2fs_maxfilesize = 0x7fffffffffffffff; in ext2_compute_sb_data()
704 fs->e2fs_uhash = 3; in ext2_compute_sb_data()
708 fs->e2fs_uhash = 3; in ext2_compute_sb_data()
713 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) in ext2_compute_sb_data()
714 error = ext2_sb_csum_verify(fs); in ext2_compute_sb_data()
740 struct m_ext2fs *fs; in ext2_reload() local
767 fs = VFSTOEXT2(mp)->um_e2fs; in ext2_reload()
768 bcopy(bp->b_data, fs->e2fs, sizeof(struct ext2fs)); in ext2_reload()
770 if ((error = ext2_compute_sb_data(devvp, es, fs)) != 0) { in ext2_reload()
780 if (fs->e2fs_contigsumsize > 0) { in ext2_reload()
781 lp = fs->e2fs_maxcluster; in ext2_reload()
782 sump = fs->e2fs_clustersum; in ext2_reload()
783 for (i = 0; i < fs->e2fs_gcount; i++, sump++) { in ext2_reload()
784 *lp++ = fs->e2fs_contigsumsize; in ext2_reload()
786 bzero(sump->cs_sum, fs->e2fs_contigsumsize + 1); in ext2_reload()
806 error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), in ext2_reload()
807 (int)fs->e2fs_bsize, NOCRED, &bp); in ext2_reload()
815 EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)), ip); in ext2_reload()
836 struct m_ext2fs *fs; in ext2_mountfs() local
853 /* XXX: use VOP_ACESS to check FS perms */ in ext2_mountfs()
941 fs = ump->um_e2fs; in ext2_mountfs()
942 fs->e2fs_ronly = ronly; /* ronly is set according to mnt_flags */ in ext2_mountfs()
945 * If the fs is not mounted read-only, make sure the super block is in ext2_mountfs()
948 fs->e2fs_wasvalid = le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN ? 1 : 0; in ext2_mountfs()
950 fs->e2fs_fmod = 1; /* mark it modified and set fs invalid */ in ext2_mountfs()
951 fs->e2fs->e2fs_state = in ext2_mountfs()
952 htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN); in ext2_mountfs()
970 ump->um_nindir = EXT2_ADDR_PER_BLOCK(fs); in ext2_mountfs()
971 ump->um_bptrtodb = le32toh(fs->e2fs->e2fs_log_bsize) + 1; in ext2_mountfs()
972 ump->um_seqinc = EXT2_FRAGS_PER_BLOCK(fs); in ext2_mountfs()
1010 struct m_ext2fs *fs; in ext2_unmount() local
1023 fs = ump->um_e2fs; in ext2_unmount()
1024 ronly = fs->e2fs_ronly; in ext2_unmount()
1026 if (fs->e2fs_wasvalid) in ext2_unmount()
1027 fs->e2fs->e2fs_state = in ext2_unmount()
1028 htole16(le16toh(fs->e2fs->e2fs_state) | E2FS_ISCLEAN); in ext2_unmount()
1036 sump = fs->e2fs_clustersum; in ext2_unmount()
1037 for (i = 0; i < fs->e2fs_gcount; i++, sump++) in ext2_unmount()
1039 free(fs->e2fs_clustersum, M_EXT2MNT); in ext2_unmount()
1040 free(fs->e2fs_maxcluster, M_EXT2MNT); in ext2_unmount()
1041 free(fs->e2fs_gd, M_EXT2MNT); in ext2_unmount()
1042 free(fs->e2fs_contigdirs, M_EXT2MNT); in ext2_unmount()
1043 free(fs->e2fs, M_EXT2MNT); in ext2_unmount()
1044 free(fs, M_EXT2MNT); in ext2_unmount()
1069 struct m_ext2fs *fs; in ext2_statfs() local
1074 fs = ump->um_e2fs; in ext2_statfs()
1075 if (le16toh(fs->e2fs->e2fs_magic) != E2FS_MAGIC) in ext2_statfs()
1079 * Compute the overhead (FS structures) in ext2_statfs()
1084 fs->e2fs_itpg; in ext2_statfs()
1085 overhead = le32toh(fs->e2fs->e2fs_first_dblock) + in ext2_statfs()
1086 fs->e2fs_gcount * overhead_per_group; in ext2_statfs()
1087 if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 && in ext2_statfs()
1088 le32toh(fs->e2fs->e2fs_features_rocompat) & EXT2F_ROCOMPAT_SPARSESUPER) { in ext2_statfs()
1089 for (i = 0, ngroups = 0; i < fs->e2fs_gcount; i++) { in ext2_statfs()
1090 if (ext2_cg_has_sb(fs, i)) in ext2_statfs()
1094 ngroups = fs->e2fs_gcount; in ext2_statfs()
1096 ngdb = fs->e2fs_gdbcount; in ext2_statfs()
1097 if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 && in ext2_statfs()
1098 le32toh(fs->e2fs->e2fs_features_compat) & EXT2F_COMPAT_RESIZE) in ext2_statfs()
1099 ngdb += le16toh(fs->e2fs->e2fs_reserved_ngdb); in ext2_statfs()
1102 sbp->f_bsize = EXT2_FRAG_SIZE(fs); in ext2_statfs()
1103 sbp->f_iosize = EXT2_BLOCK_SIZE(fs); in ext2_statfs()
1104 sbp->f_blocks = fs->e2fs_bcount - overhead; in ext2_statfs()
1105 sbp->f_bfree = fs->e2fs_fbcount; in ext2_statfs()
1106 sbp->f_bavail = sbp->f_bfree - fs->e2fs_rbcount; in ext2_statfs()
1107 sbp->f_files = le32toh(fs->e2fs->e2fs_icount); in ext2_statfs()
1108 sbp->f_ffree = fs->e2fs_ficount; in ext2_statfs()
1126 struct m_ext2fs *fs; in ext2_sync() local
1130 fs = ump->um_e2fs; in ext2_sync()
1131 if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) { /* XXX */ in ext2_sync()
1132 panic("ext2_sync: rofs mod fs=%s", fs->e2fs_fsmnt); in ext2_sync()
1178 if (fs->e2fs_fmod != 0) { in ext2_sync()
1179 fs->e2fs_fmod = 0; in ext2_sync()
1180 fs->e2fs->e2fs_wtime = htole32(time_second); in ext2_sync()
1196 struct m_ext2fs *fs; in ext2_vget() local
1221 ip->i_e2fs = fs = ump->um_e2fs; in ext2_vget()
1238 if ((error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)), in ext2_vget()
1239 (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { in ext2_vget()
1253 EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ino)), ip); in ext2_vget()
1260 ip->i_block_group = ino_to_cg(fs, ino); in ext2_vget()
1274 used_blocks = howmany(ip->i_size, fs->e2fs_bsize); in ext2_vget()
1326 struct m_ext2fs *fs; in ext2_fhtovp() local
1330 fs = VFSTOEXT2(mp)->um_e2fs; in ext2_fhtovp()
1332 ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs_ipg) in ext2_fhtovp()
1358 struct m_ext2fs *fs = mp->um_e2fs; in ext2_sbupdate() local
1359 struct ext2fs *es = fs->e2fs; in ext2_sbupdate()
1363 es->e2fs_bcount = htole32(fs->e2fs_bcount & 0xffffffff); in ext2_sbupdate()
1364 es->e2fs_rbcount = htole32(fs->e2fs_rbcount & 0xffffffff); in ext2_sbupdate()
1365 es->e2fs_fbcount = htole32(fs->e2fs_fbcount & 0xffffffff); in ext2_sbupdate()
1366 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) { in ext2_sbupdate()
1367 es->e4fs_bcount_hi = htole32(fs->e2fs_bcount >> 32); in ext2_sbupdate()
1368 es->e4fs_rbcount_hi = htole32(fs->e2fs_rbcount >> 32); in ext2_sbupdate()
1369 es->e4fs_fbcount_hi = htole32(fs->e2fs_fbcount >> 32); in ext2_sbupdate()
1372 es->e2fs_ficount = htole32(fs->e2fs_ficount); in ext2_sbupdate()
1374 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) in ext2_sbupdate()
1375 ext2_sb_csum_set(fs); in ext2_sbupdate()
1398 struct m_ext2fs *fs = mp->um_e2fs; in ext2_cgupdate() local
1405 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) || in ext2_cgupdate()
1406 EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) in ext2_cgupdate()
1407 ext2_gd_csum_set(fs); in ext2_cgupdate()
1409 for (i = 0; i < fs->e2fs_gdbcount; i++) { in ext2_cgupdate()
1410 bp = getblk(mp->um_devvp, fsbtodb(fs, in ext2_cgupdate()
1411 ext2_cg_location(fs, i)), in ext2_cgupdate()
1412 fs->e2fs_bsize, 0, 0, 0); in ext2_cgupdate()
1413 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) { in ext2_cgupdate()
1414 memcpy(bp->b_data, &fs->e2fs_gd[ in ext2_cgupdate()
1415 i * fs->e2fs_bsize / sizeof(struct ext2_gd)], in ext2_cgupdate()
1416 fs->e2fs_bsize); in ext2_cgupdate()
1418 for (j = 0; j < fs->e2fs_bsize / E2FS_REV0_GD_SIZE && in ext2_cgupdate()
1419 g_count < fs->e2fs_gcount; j++, g_count++) in ext2_cgupdate()
1421 &fs->e2fs_gd[g_count], E2FS_REV0_GD_SIZE); in ext2_cgupdate()