void
xfs_dir_mount(
xfs_mount_t *mp)
{
int nodehdr_size;
ASSERT(xfs_sb_version_hasdirv2(&mp->m_sb));
ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
XFS_MAX_BLOCKSIZE);
mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
mp->m_dirblkfsbs = 1 << mp->m_sb.sb_dirblklog;
mp->m_dirdatablk = xfs_dir2_db_to_da(mp, XFS_DIR2_DATA_FIRSTDB(mp));
mp->m_dirleafblk = xfs_dir2_db_to_da(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
mp->m_dirfreeblk = xfs_dir2_db_to_da(mp, XFS_DIR2_FREE_FIRSTDB(mp));
nodehdr_size = __xfs_da3_node_hdr_size(xfs_sb_version_hascrc(&mp->m_sb));
mp->m_attr_node_ents = (mp->m_sb.sb_blocksize - nodehdr_size) /
(uint)sizeof(xfs_da_node_entry_t);
mp->m_dir_node_ents = (mp->m_dirblksize - nodehdr_size) /
(uint)sizeof(xfs_da_node_entry_t);
mp->m_dir_magicpct = (mp->m_dirblksize * 37) / 100;
if (xfs_sb_version_hasasciici(&mp->m_sb))
mp->m_dirnameops = &xfs_ascii_ci_nameops;
else
mp->m_dirnameops = &xfs_default_nameops;
}
static int
inode_u_sfdir2_count(
void *obj,
int startoff)
{
xfs_dinode_t *dip;
ASSERT(bitoffs(startoff) == 0);
ASSERT(obj == iocur_top->data);
dip = obj;
ASSERT((char *)XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
return dip->di_format == XFS_DINODE_FMT_LOCAL &&
(be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFDIR &&
xfs_sb_version_hasdirv2(&mp->m_sb) &&
!xfs_sb_version_hasftype(&mp->m_sb);
}
void
xfs_dir_mount(
xfs_mount_t *mp)
{
ASSERT(xfs_sb_version_hasdirv2(&mp->m_sb));
ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
XFS_MAX_BLOCKSIZE);
mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
mp->m_dirblkfsbs = 1 << mp->m_sb.sb_dirblklog;
mp->m_dirdatablk = xfs_dir2_db_to_da(mp, XFS_DIR2_DATA_FIRSTDB(mp));
mp->m_dirleafblk = xfs_dir2_db_to_da(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
mp->m_dirfreeblk = xfs_dir2_db_to_da(mp, XFS_DIR2_FREE_FIRSTDB(mp));
mp->m_attr_node_ents =
(mp->m_sb.sb_blocksize - (uint)sizeof(xfs_da_node_hdr_t)) /
(uint)sizeof(xfs_da_node_entry_t);
mp->m_dir_node_ents =
(mp->m_dirblksize - (uint)sizeof(xfs_da_node_hdr_t)) /
(uint)sizeof(xfs_da_node_entry_t);
mp->m_dir_magicpct = (mp->m_dirblksize * 37) / 100;
}
/*
* Possible fields that may have been set at mkfs time,
* sb_inoalignmt, sb_unit, sb_width and sb_dirblklog.
* The quota inode fields in the secondaries should be zero.
* Likewise, the sb_flags and sb_shared_vn should also be
* zero and the shared version bit should be cleared for
* current mkfs's.
*
* And everything else in the buffer beyond either sb_width,
* sb_dirblklog (v2 dirs), or sb_logsectsize can be zeroed.
*
* Note: contrary to the name, this routine is called for all
* superblocks, not just the secondary superblocks.
*/
static int
secondary_sb_wack(xfs_mount_t *mp, xfs_buf_t *sbuf, xfs_sb_t *sb,
xfs_agnumber_t i)
{
int do_bzero;
int size;
char *ip;
int rval;
rval = do_bzero = 0;
/*
* mkfs's that stamped a feature bit besides the ones in the mask
* (e.g. were pre-6.5 beta) could leave garbage in the secondary
* superblock sectors. Anything stamping the shared fs bit or better
* into the secondaries is ok and should generate clean secondary
* superblock sectors. so only run the zero check on the
* potentially garbaged secondaries.
*/
if (pre_65_beta ||
(sb->sb_versionnum & XR_GOOD_SECSB_VNMASK) == 0 ||
sb->sb_versionnum < XFS_SB_VERSION_4) {
/*
* Check for garbage beyond the last field.
* Use field addresses instead so this code will still
* work against older filesystems when the superblock
* gets rev'ed again with new fields appended.
*/
if (xfs_sb_version_hasmorebits(sb))
size = (__psint_t)&sb->sb_features2
+ sizeof(sb->sb_features2) - (__psint_t)sb;
else if (xfs_sb_version_haslogv2(sb))
size = (__psint_t)&sb->sb_logsunit
+ sizeof(sb->sb_logsunit) - (__psint_t)sb;
else if (xfs_sb_version_hassector(sb))
size = (__psint_t)&sb->sb_logsectsize
+ sizeof(sb->sb_logsectsize) - (__psint_t)sb;
else if (xfs_sb_version_hasdirv2(sb))
size = (__psint_t)&sb->sb_dirblklog
+ sizeof(sb->sb_dirblklog) - (__psint_t)sb;
else
size = (__psint_t)&sb->sb_width
+ sizeof(sb->sb_width) - (__psint_t)sb;
for (ip = (char *)((__psint_t)sb + size);
ip < (char *)((__psint_t)sb + mp->m_sb.sb_sectsize);
ip++) {
if (*ip) {
do_bzero = 1;
break;
}
}
if (do_bzero) {
rval |= XR_AG_SB_SEC;
if (!no_modify) {
do_warn(
_("zeroing unused portion of %s superblock (AG #%u)\n"),
!i ? _("primary") : _("secondary"), i);
memset((void *)((__psint_t)sb + size), 0,
mp->m_sb.sb_sectsize - size);
} else
do_warn(
_("would zero unused portion of %s superblock (AG #%u)\n"),
!i ? _("primary") : _("secondary"), i);
}
}
/*
* now look for the fields we can manipulate directly.
* if we did a zero and that zero could have included
* the field in question, just silently reset it. otherwise,
* complain.
*
* for now, just zero the flags field since only
* the readonly flag is used
*/
if (sb->sb_flags) {
if (!no_modify)
sb->sb_flags = 0;
if (sb->sb_versionnum & XR_PART_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(_("bad flags field in superblock %d\n"), i);
} else
rval |= XR_AG_SB_SEC;
}
/*
* quota inodes and flags in secondary superblocks
* are never set by mkfs. However, they could be set
* in a secondary if a fs with quotas was growfs'ed since
* growfs copies the new primary into the secondaries.
*/
if (sb->sb_inprogress == 1 && sb->sb_uquotino) {
if (!no_modify)
sb->sb_uquotino = 0;
if (sb->sb_versionnum & XR_PART_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(
_("non-null user quota inode field in superblock %d\n"),
i);
} else
rval |= XR_AG_SB_SEC;
}
if (sb->sb_inprogress == 1 && sb->sb_gquotino) {
if (!no_modify)
sb->sb_gquotino = 0;
if (sb->sb_versionnum & XR_PART_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(
_("non-null group quota inode field in superblock %d\n"),
i);
} else
rval |= XR_AG_SB_SEC;
}
if (sb->sb_inprogress == 1 && sb->sb_qflags) {
if (!no_modify)
sb->sb_qflags = 0;
if (sb->sb_versionnum & XR_PART_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(_("non-null quota flags in superblock %d\n"),
i);
} else
rval |= XR_AG_SB_SEC;
}
/*
* if the secondaries agree on a stripe unit/width or inode
* alignment, those fields ought to be valid since they are
* written at mkfs time (and the corresponding sb version bits
* are set).
*/
if (!xfs_sb_version_hasshared(sb) && sb->sb_shared_vn != 0) {
if (!no_modify)
sb->sb_shared_vn = 0;
if (sb->sb_versionnum & XR_PART_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(
_("bad shared version number in superblock %d\n"),
i);
} else
rval |= XR_AG_SB_SEC;
}
if (!xfs_sb_version_hasalign(sb) && sb->sb_inoalignmt != 0) {
if (!no_modify)
sb->sb_inoalignmt = 0;
if (sb->sb_versionnum & XR_PART_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(
_("bad inode alignment field in superblock %d\n"),
i);
} else
rval |= XR_AG_SB_SEC;
}
if (!xfs_sb_version_hasdalign(sb) &&
(sb->sb_unit != 0 || sb->sb_width != 0)) {
if (!no_modify)
sb->sb_unit = sb->sb_width = 0;
if (sb->sb_versionnum & XR_GOOD_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(
_("bad stripe unit/width fields in superblock %d\n"),
i);
} else
rval |= XR_AG_SB_SEC;
}
if (!xfs_sb_version_hassector(sb) &&
(sb->sb_sectsize != BBSIZE || sb->sb_sectlog != BBSHIFT ||
sb->sb_logsectsize != 0 || sb->sb_logsectlog != 0)) {
if (!no_modify) {
sb->sb_sectsize = BBSIZE;
sb->sb_sectlog = BBSHIFT;
sb->sb_logsectsize = 0;
sb->sb_logsectlog = 0;
}
if (sb->sb_versionnum & XR_GOOD_SECSB_VNMASK || !do_bzero) {
rval |= XR_AG_SB;
do_warn(
_("bad log/data device sector size fields in superblock %d\n"),
i);
} else
rval |= XR_AG_SB_SEC;
}
return(rval);
}