fs32_to_cpu
sup->magic = fs32_to_cpu(sb, od_sup->magic);
sup->node_size = fs32_to_cpu(sb, od_sup->node_size);
sup->max_depth = fs32_to_cpu(sb, od_sup->max_depth);
sup->data_type = fs32_to_cpu(sb, od_sup->data_type);
fs32_to_cpu(sb, array[j].allocation_group);
befs_debug(sb, " type %08x", fs32_to_cpu(sb, inode->type));
befs_debug(sb, " inode_size %u", fs32_to_cpu(sb, inode->inode_size));
if (S_ISLNK(fs32_to_cpu(sb, inode->mode))) {
befs_debug(sb, " magic1 %08x", fs32_to_cpu(sb, sup->magic1));
fs32_to_cpu(sb, sup->fs_byte_order));
befs_debug(sb, " block_size %u", fs32_to_cpu(sb, sup->block_size));
befs_debug(sb, " block_shift %u", fs32_to_cpu(sb, sup->block_shift));
befs_debug(sb, " inode_size %u", fs32_to_cpu(sb, sup->inode_size));
befs_debug(sb, " magic2 %08x", fs32_to_cpu(sb, sup->magic2));
fs32_to_cpu(sb, sup->blocks_per_ag));
befs_debug(sb, " ag_shift %u", fs32_to_cpu(sb, sup->ag_shift));
befs_debug(sb, " num_ags %u", fs32_to_cpu(sb, sup->num_ags));
befs_debug(sb, " flags %08x", fs32_to_cpu(sb, sup->flags));
befs_debug(sb, " magic3 %08x", fs32_to_cpu(sb, sup->magic3));
befs_debug(sb, " magic %08x", fs32_to_cpu(sb, super->magic));
befs_debug(sb, " node_size %u", fs32_to_cpu(sb, super->node_size));
befs_debug(sb, " max_depth %08x", fs32_to_cpu(sb, super->max_depth));
befs_debug(sb, " data_type %08x", fs32_to_cpu(sb, super->data_type));
befs_debug(sb, " magic1 %08x", fs32_to_cpu(sb, inode->magic1));
befs_debug(sb, " uid %u", fs32_to_cpu(sb, inode->uid));
befs_debug(sb, " gid %u", fs32_to_cpu(sb, inode->gid));
befs_debug(sb, " mode %08x", fs32_to_cpu(sb, inode->mode));
befs_debug(sb, " flags %08x", fs32_to_cpu(sb, inode->flags));
u32 magic1 = fs32_to_cpu(sb, raw_inode->magic1);
u32 flags = fs32_to_cpu(sb, raw_inode->flags);
inode->i_mode = (umode_t) fs32_to_cpu(sb, raw_inode->mode);
make_kuid(&init_user_ns, fs32_to_cpu(sb, raw_inode->uid));
make_kgid(&init_user_ns, fs32_to_cpu(sb, raw_inode->gid));
befs_ino->i_flags = fs32_to_cpu(sb, raw_inode->flags);
befs_sb->magic1 = fs32_to_cpu(sb, disk_sb->magic1);
befs_sb->magic2 = fs32_to_cpu(sb, disk_sb->magic2);
befs_sb->magic3 = fs32_to_cpu(sb, disk_sb->magic3);
befs_sb->block_size = fs32_to_cpu(sb, disk_sb->block_size);
befs_sb->block_shift = fs32_to_cpu(sb, disk_sb->block_shift);
befs_sb->inode_size = fs32_to_cpu(sb, disk_sb->inode_size);
befs_sb->blocks_per_ag = fs32_to_cpu(sb, disk_sb->blocks_per_ag);
befs_sb->ag_shift = fs32_to_cpu(sb, disk_sb->ag_shift);
befs_sb->num_ags = fs32_to_cpu(sb, disk_sb->num_ags);
befs_sb->flags = fs32_to_cpu(sb, disk_sb->flags);
fs32_to_cpu(sbi, typ->vt_block),
fs32_to_cpu(sbi, typ->vt_size),
if ((block - off) >= fs32_to_cpu(sbi, typ->vt_size))
pblock = fs32_to_cpu(sbi, typ->vt_block) + block - off;
fs32_to_cpu(sbi, typ4->vd4_dev));
fs32_to_cpu(sbi, typ->vt_block),
fs32_to_cpu(sbi, typ->vt_size),
if ((iblock - off) < fs32_to_cpu(sbi, typ->vt_size))
return (fs32_to_cpu(sbi, typ->vt_block) +
fs32_to_cpu(sbi, typ4->vd4_dev));
u32 indsize = fs32_to_cpu(sbi, vip->vii_ext4.ve4_indsize);
if (bn >= 0 && bn < fs32_to_cpu(sbi, d->size))
return (bn + fs32_to_cpu(sbi, d->extent));
bn -= fs32_to_cpu(sbi, d->size);
fs32_to_cpu(sbi, vip->vii_ext4.ve4_indir[0]));
bno = fs32_to_cpu(sbi, indir[(bn / indsize) % (indsize * bn)]) +
fs32_to_cpu(infp, sfp->fsh_ilistino[0]));
infp->vsi_ilist = vxfs_stiget(sbp, fs32_to_cpu(infp, pfp->fsh_ilistino[0]));
vip->vii_rdev = fs32_to_cpu(sbi, dip->vdi_rdev);
vip->vii_mode = fs32_to_cpu(sbi, dip->vdi_mode);
vip->vii_nlink = fs32_to_cpu(sbi, dip->vdi_nlink);
vip->vii_uid = fs32_to_cpu(sbi, dip->vdi_uid);
vip->vii_gid = fs32_to_cpu(sbi, dip->vdi_gid);
vip->vii_atime = fs32_to_cpu(sbi, dip->vdi_atime);
vip->vii_autime = fs32_to_cpu(sbi, dip->vdi_autime);
vip->vii_mtime = fs32_to_cpu(sbi, dip->vdi_mtime);
vip->vii_mutime = fs32_to_cpu(sbi, dip->vdi_mutime);
vip->vii_ctime = fs32_to_cpu(sbi, dip->vdi_ctime);
vip->vii_cutime = fs32_to_cpu(sbi, dip->vdi_cutime);
vip->vii_blocks = fs32_to_cpu(sbi, dip->vdi_blocks);
vip->vii_gen = fs32_to_cpu(sbi, dip->vdi_gen);
vip->vii_dotdot = fs32_to_cpu(sbi, dip->vdi_dotdot);
ino = fs32_to_cpu(VXFS_SBI(dip->i_sb), de->d_ino);
fs32_to_cpu(sbi, de->d_ino),
infp->vsi_fshino = fs32_to_cpu(infp, fshp->olt_fsino[0]);
infp->vsi_iext = fs32_to_cpu(infp, ilistp->olt_iext[0]);
if (fs32_to_cpu(infp, op->olt_magic) != VXFS_OLT_MAGIC) {
oaddr = bp->b_data + fs32_to_cpu(infp, op->olt_size);
switch (fs32_to_cpu(infp, ocp->olt_type)) {
oaddr += fs32_to_cpu(infp, ocp->olt_size);
j = fs32_to_cpu(infp, rsbp->vs_version);
fs32_to_cpu(infp, rsbp->vs_bsize));
sbp->s_magic = fs32_to_cpu(infp, rsbp->vs_magic);
infp->vsi_oltext = fs32_to_cpu(infp, rsbp->vs_oltext[0]);
infp->vsi_oltsize = fs32_to_cpu(infp, rsbp->vs_oltsize);
j = fs32_to_cpu(infp, rsbp->vs_bsize);
bufp->f_blocks = fs32_to_cpu(infp, raw_sb->vs_dsize);
bufp->f_bfree = fs32_to_cpu(infp, raw_sb->vs_free);
bufp->f_ffree = fs32_to_cpu(infp, raw_sb->vs_ifree);
if (!test_opt(s, MMI_FS) && fs32_to_cpu(sbi, de->de_checksum) !=
u32 no_inode = fs32_to_cpu(sbi, de->de_inode);
return fs32_to_cpu(sbi, de->de_inode);
return fs32_to_cpu(sbi, de->de_inode);
u32 s = fs32_to_cpu(sbi, de->de_long_inode); /* in block units */
buf->f_blocks = fs32_to_cpu(sbi, sbi->sb->sb_num_blocks);
buf->f_bfree = fs32_to_cpu(sbi, sbi->sb->sb_free_blocks);
buf->f_files = fs32_to_cpu(sbi, sbi->sb->sb_num_inodes);
buf->f_ffree = fs32_to_cpu(sbi, sbi->sb->sb_free_inodes);
pr_debug("magic: %08x\n", fs32_to_cpu(sbi, sb->sb_magic));
pr_debug("checksum: %08x\n", fs32_to_cpu(sbi, sb->sb_checksum));
pr_debug("flags: %08x\n", fs32_to_cpu(sbi, sb->sb_flags));
pr_debug("blocksize: %08x\n", fs32_to_cpu(sbi, sb->sb_blocksize));
pr_debug("num_inodes: %08x\n", fs32_to_cpu(sbi, sb->sb_num_inodes));
pr_debug("free_inodes: %08x\n", fs32_to_cpu(sbi, sb->sb_free_inodes));
pr_debug("num_blocks: %08x\n", fs32_to_cpu(sbi, sb->sb_num_blocks));
pr_debug("free_blocks: %08x\n", fs32_to_cpu(sbi, sb->sb_free_blocks));
if (fs32_to_cpu(sbi, sb->sb_magic) != QNX6_SUPER_MAGIC) {
if (fs32_to_cpu(sbi, sb->sb_magic) == QNX6_SUPER_MAGIC) {
if (fs32_to_cpu(sbi, sb1->sb_checksum) !=
if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) {
offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) +
if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) {
if (fs32_to_cpu(sbi, sb2->sb_checksum) !=
i_uid_write(inode, (uid_t)fs32_to_cpu(sbi, raw_inode->di_uid));
i_gid_write(inode, (gid_t)fs32_to_cpu(sbi, raw_inode->di_gid));
inode_set_mtime(inode, fs32_to_cpu(sbi, raw_inode->di_mtime), 0);
inode_set_atime(inode, fs32_to_cpu(sbi, raw_inode->di_atime), 0);
inode_set_ctime(inode, fs32_to_cpu(sbi, raw_inode->di_ctime), 0);
return fs32_to_cpu(sbi, block) + sbi->s_blks_off;
if (fs32_to_cpu(sbi, sb1->sb_magic) != QNX6_SUPER_MAGIC) {
if (fs32_to_cpu(sbi, sb1->sb_checksum) !=
offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) + QNX6_SUPERBLOCK_AREA /
fs32_to_cpu(sbi, sb1->sb_blocksize);
if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) {
if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) {
if (fs32_to_cpu(sbi, sb2->sb_checksum)
if (fs32_to_cpu(sb, usb1->fs_optim) == UFS_OPTSPACE) {
if (fs32_to_cpu(sb, UFS_SB(sb)->fs_cs(cgno).cs_nffree) < count)
if (!fs32_to_cpu(sb, ucg->cg_frsum[fragsize]))
if (fs32_to_cpu(sb, ucg->cg_cs.cs_nbfree)) \
if (fs32_to_cpu(sb, ucg->cg_frsum[k])) \
if (fs32_to_cpu(sb, ucg->cg_frsum[allocsize]) != 0)
ucpi->c_cgx = fs32_to_cpu(sb, ucg->cg_cgx);
ucpi->c_ndblk = fs32_to_cpu(sb, ucg->cg_ndblk);
ucpi->c_rotor = fs32_to_cpu(sb, ucg->cg_rotor);
ucpi->c_frotor = fs32_to_cpu(sb, ucg->cg_frotor);
ucpi->c_irotor = fs32_to_cpu(sb, ucg->cg_irotor);
ucpi->c_btotoff = fs32_to_cpu(sb, ucg->cg_btotoff);
ucpi->c_boff = fs32_to_cpu(sb, ucg->cg_boff);
ucpi->c_iusedoff = fs32_to_cpu(sb, ucg->cg_iusedoff);
ucpi->c_freeoff = fs32_to_cpu(sb, ucg->cg_freeoff);
ucpi->c_nextfreeoff = fs32_to_cpu(sb, ucg->cg_nextfreeoff);
ucpi->c_clustersumoff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clustersumoff);
ucpi->c_clusteroff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clusteroff);
ucpi->c_nclusterblks = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_nclusterblks);
if (fs32_to_cpu(sb, p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
fs32_to_cpu(sb, de->d_ino));
fs32_to_cpu(sb, de->d_ino),
fs32_to_cpu(sb, de->d_ino),
fs32_to_cpu(sb, de->d_ino))
res = fs32_to_cpu(dir->i_sb, de->d_ino);
fs32_to_cpu(sb, ucg->cg_u.cg_u2.cg_initediblk));
u32 initediblk = fs32_to_cpu(sb, ucg->cg_u.cg_u2.cg_initediblk);
initediblk < fs32_to_cpu(sb, ucg->cg_u.cg_u2.cg_niblk))
fs32_to_cpu(sb, q->key32) + (n>>shift));
res = fs32_to_cpu(sb, q->key32);
(tmp = fs32_to_cpu(sb, ((__fs32 *)bh->b_data)[index-1]))))
(signed)fs32_to_cpu(sb, ufs_inode->ui_atime.tv_sec),
(signed)fs32_to_cpu(sb, ufs_inode->ui_ctime.tv_sec),
(signed)fs32_to_cpu(sb, ufs_inode->ui_mtime.tv_sec),
inode->i_blocks = fs32_to_cpu(sb, ufs_inode->ui_blocks);
inode->i_generation = fs32_to_cpu(sb, ufs_inode->ui_gen);
ufsi->i_flags = fs32_to_cpu(sb, ufs_inode->ui_flags);
ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
i_uid_write(inode, fs32_to_cpu(sb, ufs2_inode->ui_uid));
i_gid_write(inode, fs32_to_cpu(sb, ufs2_inode->ui_gid));
fs32_to_cpu(sb, ufs2_inode->ui_atimensec));
fs32_to_cpu(sb, ufs2_inode->ui_ctimensec));
fs32_to_cpu(sb, ufs2_inode->ui_mtimensec));
inode->i_generation = fs32_to_cpu(sb, ufs2_inode->ui_gen);
ufsi->i_flags = fs32_to_cpu(sb, ufs2_inode->ui_flags);
uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
(ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
u32 magic = fs32_to_cpu(sb, usb3->fs_magic);
if (fs32_to_cpu(sb, usb3->fs_magic) == UFS2_MAGIC) {
fs32_to_cpu(sb, usb1->fs_bsize));
fs32_to_cpu(sb, usb1->fs_fsize));
fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen));
pr_debug(" sblkno: %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
pr_debug(" cblkno: %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
pr_debug(" iblkno: %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
pr_debug(" dblkno: %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
fs32_to_cpu(sb, usb1->fs_cgoffset));
~fs32_to_cpu(sb, usb1->fs_cgmask));
pr_debug(" size: %u\n", fs32_to_cpu(sb, usb1->fs_size));
pr_debug(" dsize: %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
pr_debug(" ncg: %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
pr_debug(" bsize: %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
pr_debug(" fsize: %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
pr_debug(" frag: %u\n", fs32_to_cpu(sb, usb1->fs_frag));
fs32_to_cpu(sb, usb1->fs_fragshift));
pr_debug(" ~fmask: %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
pr_debug(" fshift: %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
pr_debug(" sbsize: %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
pr_debug(" spc: %u\n", fs32_to_cpu(sb, usb1->fs_spc));
pr_debug(" cpg: %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
pr_debug(" ipg: %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
pr_debug(" fpg: %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
pr_debug(" csaddr: %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
pr_debug(" cssize: %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
pr_debug(" cgsize: %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
fs32_to_cpu(sb, usb1->fs_fsbtodb));
pr_debug(" nrpos: %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
pr_debug(" magic: %x\n", fs32_to_cpu(sb, cg->cg_magic));
pr_debug(" time: %u\n", fs32_to_cpu(sb, cg->cg_time));
pr_debug(" cgx: %u\n", fs32_to_cpu(sb, cg->cg_cgx));
pr_debug(" ndblk: %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
pr_debug(" cs_ndir: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
pr_debug(" cs_nbfree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
pr_debug(" cs_nifree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
pr_debug(" cs_nffree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
pr_debug(" rotor: %u\n", fs32_to_cpu(sb, cg->cg_rotor));
pr_debug(" frotor: %u\n", fs32_to_cpu(sb, cg->cg_frotor));
pr_debug(" irotor: %u\n", fs32_to_cpu(sb, cg->cg_irotor));
fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
pr_debug(" btotoff: %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
pr_debug(" boff: %u\n", fs32_to_cpu(sb, cg->cg_boff));
pr_debug(" iuseoff: %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
pr_debug(" freeoff: %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
pr_debug(" nextfreeoff: %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);
uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);
uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
(fs32_to_cpu((sb), (ucg)->cg_magic) == CG_MAGIC)
#define ufs_ocg_blktot(sb, ucg) fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_btot)
#define ufs_ocg_blks(sb, ucg, cylno) fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_b[cylno])
#define ufs_ocg_inosused(sb, ucg) fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_iused)
#define ufs_ocg_blksfree(sb, ucg) fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_free)
(fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_magic) == CG_MAGIC)
fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[1]);
fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[0]);
return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_uid);
return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_uid);
return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_gid);
return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_gid);
if (fs32_to_cpu(sb, usb3->fs_postblformat) == UFS_42POSTBLFMT)
return fs32_to_cpu(sb, usb1->fs_u0.fs_sun.fs_state);
return fs32_to_cpu(sb, usb3->fs_un2.fs_sun.fs_state);
return fs32_to_cpu(sb, usb1->fs_u1.fs_sunx86.fs_state);
return fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_state);
fs32_to_cpu(sb, *(__fs32 *)p);
if (fs32_to_cpu(sb, usb3->fs_postblformat) == UFS_42POSTBLFMT) {
return fs32_to_cpu(sb, usb3->fs_un2.fs_sunx86.fs_npsect);
return fs32_to_cpu(sb, usb1->fs_u1.fs_sun.fs_npsect);