/* We don't yet know the sector size, so read maximal size */
libxfs_buftarg_init(&mbuf, xargs.ddev, xargs.logdev, xargs.rtdev);
- error = -libxfs_buf_read_uncached(mbuf.m_ddev_targp, XFS_SB_DADDR,
+ error = -xfs_buf_read_uncached(mbuf.m_ddev_targp, XFS_SB_DADDR,
1 << (XFS_MAX_SECTORSIZE_LOG - BBSHIFT), 0, &sbp, NULL);
if (error) {
do_log(_("%s: couldn't read superblock, error=%d\n"),
}
sb = &mbuf.m_sb;
- libxfs_sb_from_disk(sb, sbp->b_addr);
+ xfs_sb_from_disk(sb, sbp->b_addr);
/* Do it again, now with proper length and verifier */
- libxfs_buf_relse(sbp);
+ xfs_buf_relse(sbp);
- error = -libxfs_buf_read(mbuf.m_ddev_targp, XFS_SB_DADDR,
+ error = -xfs_buf_read(mbuf.m_ddev_targp, XFS_SB_DADDR,
1 << (sb->sb_sectlog - BBSHIFT), 0, &sbp,
&xfs_sb_buf_ops);
if (error) {
progname, error);
exit(1);
}
- libxfs_buf_relse(sbp);
+ xfs_buf_relse(sbp);
mp = libxfs_mount(&mbuf, sb, xargs.ddev, xargs.logdev, xargs.rtdev, 0);
if (mp == NULL) {
void *obj,
int startoff)
{
- return libxfs_agfl_size(mp);
+ return xfs_agfl_size(mp);
}
static void
switch (c) {
/* namespaces */
case 'r':
- args.attr_filter |= LIBXFS_ATTR_ROOT;
- args.attr_filter &= ~LIBXFS_ATTR_SECURE;
+ args.attr_filter |= XFS_ATTR_ROOT;
+ args.attr_filter &= ~XFS_ATTR_SECURE;
break;
case 'u':
- args.attr_filter &= ~(LIBXFS_ATTR_ROOT |
- LIBXFS_ATTR_SECURE);
+ args.attr_filter &= ~(XFS_ATTR_ROOT |
+ XFS_ATTR_SECURE);
break;
case 's':
- args.attr_filter |= LIBXFS_ATTR_SECURE;
- args.attr_filter &= ~LIBXFS_ATTR_ROOT;
+ args.attr_filter |= XFS_ATTR_SECURE;
+ args.attr_filter &= ~XFS_ATTR_ROOT;
break;
/* modifiers */
goto out;
}
- if (libxfs_attr_set(&args)) {
+ if (xfs_attr_set(&args)) {
dbprintf(_("failed to set attr %s on inode %llu\n"),
args.name, (unsigned long long)iocur_top->ino);
goto out;
switch (c) {
/* namespaces */
case 'r':
- args.attr_filter |= LIBXFS_ATTR_ROOT;
- args.attr_filter &= ~LIBXFS_ATTR_SECURE;
+ args.attr_filter |= XFS_ATTR_ROOT;
+ args.attr_filter &= ~XFS_ATTR_SECURE;
break;
case 'u':
- args.attr_filter &= ~(LIBXFS_ATTR_ROOT |
- LIBXFS_ATTR_SECURE);
+ args.attr_filter &= ~(XFS_ATTR_ROOT |
+ XFS_ATTR_SECURE);
break;
case 's':
- args.attr_filter |= LIBXFS_ATTR_SECURE;
- args.attr_filter &= ~LIBXFS_ATTR_ROOT;
+ args.attr_filter |= XFS_ATTR_SECURE;
+ args.attr_filter &= ~XFS_ATTR_ROOT;
break;
case 'n':
goto out;
}
- if (libxfs_attr_set(&args)) {
+ if (xfs_attr_set(&args)) {
dbprintf(_("failed to remove attr %s from inode %llu\n"),
(unsigned char *)args.name,
(unsigned long long)iocur_top->ino);
push_cur();
rblock = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
fsize = XFS_DFORK_SIZE(dip, mp, whichfork);
- pp = XFS_BMDR_PTR_ADDR(rblock, 1, libxfs_bmdr_maxrecs(fsize, 0));
+ pp = XFS_BMDR_PTR_ADDR(rblock, 1, xfs_bmdr_maxrecs(fsize, 0));
kp = XFS_BMDR_KEY_ADDR(rblock, 1);
bno = select_child(curoffset, kp, pp,
be16_to_cpu(rblock->bb_numrecs));
if (be16_to_cpu(block->bb_level) == 0)
break;
pp = XFS_BMBT_PTR_ADDR(mp, block, 1,
- libxfs_bmbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0));
+ xfs_bmbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0));
kp = XFS_BMBT_KEY_ADDR(mp, block, 1);
bno = select_child(curoffset, kp, pp,
be16_to_cpu(block->bb_numrecs));
ASSERT(XFS_DFORK_Q(dip) && (char *)block == XFS_DFORK_APTR(dip));
ASSERT(be16_to_cpu(block->bb_level) > 0);
pp = XFS_BMDR_PTR_ADDR(block, idx,
- libxfs_bmdr_maxrecs(XFS_DFORK_ASIZE(dip, mp), 0));
+ xfs_bmdr_maxrecs(XFS_DFORK_ASIZE(dip, mp), 0));
return bitize((int)((char *)pp - (char *)block));
}
block = (xfs_bmdr_block_t *)((char *)obj + byteize(startoff));
ASSERT(be16_to_cpu(block->bb_level) > 0);
pp = XFS_BMDR_PTR_ADDR(block, idx,
- libxfs_bmdr_maxrecs(XFS_DFORK_DSIZE(dip, mp), 0));
+ xfs_bmdr_maxrecs(XFS_DFORK_DSIZE(dip, mp), 0));
return bitize((int)((char *)pp - (char *)block));
}
struct xfs_da3_icnode_hdr nhdr;
if (level > 0) {
- libxfs_da3_node_hdr_from_disk(mp, &nhdr, block);
+ xfs_da3_node_hdr_from_disk(mp, &nhdr, block);
return nhdr.forw != 0;
}
- libxfs_dir2_leaf_hdr_from_disk(mp, &lhdr, block);
+ xfs_dir2_leaf_hdr_from_disk(mp, &lhdr, block);
return lhdr.forw != 0;
}
switch (((struct xfs_da_intnode *)block)->hdr.info.magic) {
case cpu_to_be16(XFS_DIR2_LEAF1_MAGIC):
case cpu_to_be16(XFS_DIR2_LEAFN_MAGIC):
- libxfs_dir2_leaf_hdr_from_disk(mp, &lhdr, block);
+ xfs_dir2_leaf_hdr_from_disk(mp, &lhdr, block);
return 0;
case cpu_to_be16(XFS_DA_NODE_MAGIC):
- libxfs_da3_node_hdr_from_disk(mp, &nhdr, block);
+ xfs_da3_node_hdr_from_disk(mp, &nhdr, block);
return nhdr.level;
default:
return -1;
switch (((struct xfs_da_intnode *)block)->hdr.info.magic) {
case cpu_to_be16(XFS_DIR3_LEAF1_MAGIC):
case cpu_to_be16(XFS_DIR3_LEAFN_MAGIC):
- libxfs_dir2_leaf_hdr_from_disk(mp, &lhdr, block);
+ xfs_dir2_leaf_hdr_from_disk(mp, &lhdr, block);
return 0;
case cpu_to_be16(XFS_DA3_NODE_MAGIC):
- libxfs_da3_node_hdr_from_disk(mp, &nhdr, block);
+ xfs_da3_node_hdr_from_disk(mp, &nhdr, block);
return nhdr.level;
default:
return -1;
struct xfs_da3_icnode_hdr nhdr;
if (level > 0) {
- libxfs_da3_node_hdr_from_disk(mp, &nhdr, block);
+ xfs_da3_node_hdr_from_disk(mp, &nhdr, block);
return nhdr.forw != 0;
}
xfs_attr3_leaf_hdr_to_disk(mp->m_attr_geo, &lhdr, block);
xfs_attr3_leaf_hdr_to_disk(mp->m_attr_geo, &lhdr, block);
return 0;
case cpu_to_be16(XFS_DA_NODE_MAGIC):
- libxfs_da3_node_hdr_from_disk(mp, &nhdr, block);
+ xfs_da3_node_hdr_from_disk(mp, &nhdr, block);
return nhdr.level;
default:
return -1;
xfs_attr3_leaf_hdr_to_disk(mp->m_attr_geo, &lhdr, block);
return 0;
case cpu_to_be16(XFS_DA3_NODE_MAGIC):
- libxfs_da3_node_hdr_from_disk(mp, &nhdr, block);
+ xfs_da3_node_hdr_from_disk(mp, &nhdr, block);
return nhdr.level;
default:
return -1;
static int refc_maxrecs(struct xfs_mount *mp, int blocklen, int leaf)
{
- return libxfs_refcountbt_maxrecs(blocklen, leaf != 0);
+ return xfs_refcountbt_maxrecs(blocklen, leaf != 0);
}
static int rmap_maxrecs(struct xfs_mount *mp, int blocklen, int leaf)
{
- return libxfs_rmapbt_maxrecs(blocklen, leaf);
+ return xfs_rmapbt_maxrecs(blocklen, leaf);
}
struct btmap {
int (*maxrecs)(struct xfs_mount *mp, int blocklen,
int leaf);
} maps[] = {
- {"bnobt", libxfs_allocbt_maxrecs},
- {"cntbt", libxfs_allocbt_maxrecs},
- {"inobt", libxfs_inobt_maxrecs},
- {"finobt", libxfs_inobt_maxrecs},
- {"bmapbt", libxfs_bmbt_maxrecs},
+ {"bnobt", xfs_allocbt_maxrecs},
+ {"cntbt", xfs_allocbt_maxrecs},
+ {"inobt", xfs_inobt_maxrecs},
+ {"finobt", xfs_inobt_maxrecs},
+ {"bmapbt", xfs_bmbt_maxrecs},
{"refcountbt", refc_maxrecs},
{"rmapbt", rmap_maxrecs},
};
return;
}
if (be16_to_cpu(dib->bb_numrecs) >
- libxfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork),
+ xfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork),
be16_to_cpu(dib->bb_level) == 0)) {
if (!sflag || id->ilist)
dbprintf(_("numrecs for ino %lld %s fork bmap root too "
*nex += be16_to_cpu(dib->bb_numrecs);
return;
} else {
- pp = XFS_BMDR_PTR_ADDR(dib, 1, libxfs_bmdr_maxrecs(
+ pp = XFS_BMDR_PTR_ADDR(dib, 1, xfs_bmdr_maxrecs(
XFS_DFORK_SIZE(dip, mp, whichfork), 0));
for (i = 0; i < be16_to_cpu(dib->bb_numrecs); i++)
scan_lbtree(get_unaligned_be64(&pp[i]),
return NULLFSINO;
}
db = xfs_dir2_da_to_db(mp->m_dir_geo, dabno);
- bf = libxfs_dir2_data_bestfree_p(mp, data);
+ bf = xfs_dir2_data_bestfree_p(mp, data);
ptr = (char *)data + mp->m_dir_geo->data_entry_offset;
if (be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC ||
be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC) {
(int)((char *)dep - (char *)data));
error++;
}
- tagp = libxfs_dir2_data_entry_tag_p(mp, dep);
+ tagp = xfs_dir2_data_entry_tag_p(mp, dep);
if ((char *)tagp >= endptr) {
if (!sflag || v)
dbprintf(_("dir %lld block %d bad entry at %d\n"),
(char *)dep - (char *)data);
xname.name = dep->name;
xname.len = dep->namelen;
- dir_hash_add(libxfs_dir2_hashname(mp, &xname), addr);
- ptr += libxfs_dir2_data_entsize(mp, dep->namelen);
+ dir_hash_add(xfs_dir2_hashname(mp, &xname), addr);
+ ptr += xfs_dir2_data_entsize(mp, dep->namelen);
count++;
lastfree = 0;
lino = be64_to_cpu(dep->inumber);
xfs_dir2_data_aoff_t off;
off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)data);
- bf = libxfs_dir2_data_bestfree_p(mp, data);
+ bf = xfs_dir2_data_bestfree_p(mp, data);
if (be16_to_cpu(dup->length) <
be16_to_cpu(bf[XFS_DIR2_DATA_FD_COUNT - 1].length))
return NULL;
/* xfs_inode_from_disk expects to have an mp to work with */
xino.i_mount = mp;
- libxfs_inode_from_disk(&xino, dip);
+ xfs_inode_from_disk(&xino, dip);
ino = XFS_AGINO_TO_INO(mp, be32_to_cpu(agf->agf_seqno), agino);
if (!isfree) {
error++;
return;
}
- if (!libxfs_dinode_good_version(&mp->m_sb, dip->di_version)) {
+ if (!xfs_dinode_good_version(&mp->m_sb, dip->di_version)) {
if (isfree || v)
dbprintf(_("bad version number %#x for inode %lld\n"),
dip->di_version, ino);
struct xfs_dir3_icleaf_hdr leafhdr;
leaf = iocur_top->data;
- libxfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
+ xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
switch (be16_to_cpu(leaf->hdr.info.magic)) {
case XFS_DIR3_LEAF1_MAGIC:
case XFS_DA_NODE_MAGIC:
case XFS_DA3_NODE_MAGIC:
node = iocur_top->data;
- libxfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
+ xfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
if (nodehdr.level < 1 || nodehdr.level > XFS_DA_NODE_MAXDEPTH) {
if (!sflag || v)
dbprintf(_("bad node block level %d for dir ino "
offset = mp->m_dir_geo->data_first_offset;
for (i = sf->count - 1, i8 = 0; i >= 0; i--) {
if ((intptr_t)sfe +
- libxfs_dir2_sf_entsize(mp, sf, sfe->namelen) -
+ xfs_dir2_sf_entsize(mp, sf, sfe->namelen) -
(intptr_t)sf > be64_to_cpu(dip->di_size)) {
if (!sflag)
dbprintf(_("dir %llu bad size in entry at %d\n"),
error++;
break;
}
- lino = libxfs_dir2_sf_get_ino(mp, sf, sfe);
+ lino = xfs_dir2_sf_get_ino(mp, sf, sfe);
if (lino > XFS_DIR2_MAX_SHORT_INUM)
i8++;
cid = find_inode(lino, 1);
}
offset =
xfs_dir2_sf_get_offset(sfe) +
- libxfs_dir2_sf_entsize(mp, sf, sfe->namelen);
- sfe = libxfs_dir2_sf_nextentry(mp, sf, sfe);
+ xfs_dir2_sf_entsize(mp, sf, sfe->namelen);
+ sfe = xfs_dir2_sf_nextentry(mp, sf, sfe);
}
if (i < 0 && (intptr_t)sfe - (intptr_t)sf !=
be64_to_cpu(dip->di_size)) {
dbprintf(_("dir %llu offsets too high\n"), id->ino);
error++;
}
- lino = libxfs_dir2_sf_get_parent_ino(sf);
+ lino = xfs_dir2_sf_get_parent_ino(sf);
if (lino > XFS_DIR2_MAX_SHORT_INUM)
i8++;
cid = find_inode(lino, 1);
goto pop1_out;
}
- libxfs_sb_from_disk(sb, iocur_top->data);
+ xfs_sb_from_disk(sb, iocur_top->data);
if (sb->sb_magicnum != XFS_SB_MAGIC) {
if (!sflag)
}
/* verify agf values before proceeding */
- if (be32_to_cpu(agf->agf_flfirst) >= libxfs_agfl_size(mp) ||
- be32_to_cpu(agf->agf_fllast) >= libxfs_agfl_size(mp)) {
+ if (be32_to_cpu(agf->agf_flfirst) >= xfs_agfl_size(mp) ||
+ be32_to_cpu(agf->agf_fllast) >= xfs_agfl_size(mp)) {
dbprintf(_("agf %d freelist blocks bad, skipping "
"freelist scan\n"), seqno);
pop_cur();
/* open coded xfs_buf_to_agfl_bno */
state.count = 0;
state.agno = seqno;
- libxfs_agfl_walk(mp, agf, iocur_top->bp, scan_agfl, &state);
+ xfs_agfl_walk(mp, agf, iocur_top->bp, scan_agfl, &state);
if (state.count != be32_to_cpu(agf->agf_flcount)) {
if (!sflag)
dbprintf(_("freeblk count %u != flcount %u in ag %u\n"),
ptr += be16_to_cpu(dup->length);
else {
dep = (xfs_dir2_data_entry_t *)ptr;
- ptr += libxfs_dir2_data_entsize(mp, dep->namelen);
+ ptr += xfs_dir2_data_entsize(mp, dep->namelen);
}
}
return i;
ptr += be16_to_cpu(dup->length);
else {
dep = (xfs_dir2_data_entry_t *)ptr;
- ptr += libxfs_dir2_data_entsize(mp, dep->namelen);
+ ptr += xfs_dir2_data_entsize(mp, dep->namelen);
}
}
return ptr;
end = (char *)&dep->namelen + sizeof(dep->namelen);
if (end > (char *)obj + mp->m_dir_geo->blksize)
return 0;
- tagp = libxfs_dir2_data_entry_tag_p(mp, dep);
+ tagp = xfs_dir2_data_entry_tag_p(mp, dep);
}
end = (char *)tagp + sizeof(*tagp);
return end <= (char *)obj + mp->m_dir_geo->blksize;
return bitize((int)((char *)xfs_dir2_data_unused_tag_p(dup) -
(char *)dup));
dep = (xfs_dir2_data_entry_t *)dup;
- return bitize((int)((char *)libxfs_dir2_data_entry_tag_p(mp, dep) -
+ return bitize((int)((char *)xfs_dir2_data_entry_tag_p(mp, dep) -
(char *)dep));
}
return bitize(be16_to_cpu(dup->length));
else {
dep = (xfs_dir2_data_entry_t *)dup;
- return bitize(libxfs_dir2_data_entsize(mp, dep->namelen));
+ return bitize(xfs_dir2_data_entsize(mp, dep->namelen));
}
}
sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
e = xfs_dir2_sf_firstentry(sf);
for (i = 0; i < idx; i++)
- e = libxfs_dir2_sf_nextentry(mp, sf, e);
- return bitize((int)libxfs_dir2_sf_entsize(mp, sf, e->namelen));
+ e = xfs_dir2_sf_nextentry(mp, sf, e);
+ return bitize((int)xfs_dir2_sf_entsize(mp, sf, e->namelen));
}
/*ARGSUSED*/
sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
e = xfs_dir2_sf_firstentry(sf);
for (i = 0; i < idx; i++)
- e = libxfs_dir2_sf_nextentry(mp, sf, e);
+ e = xfs_dir2_sf_nextentry(mp, sf, e);
return bitize((int)((char *)e - (char *)sf));
}
sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
e = xfs_dir2_sf_firstentry(sf);
for (i = 0; i < sf->count; i++)
- e = libxfs_dir2_sf_nextentry(mp, sf, e);
+ e = xfs_dir2_sf_nextentry(mp, sf, e);
return bitize((int)((char *)e - (char *)sf));
}
return;
}
pp = XFS_BMDR_PTR_ADDR(dib, 1,
- libxfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork), 0));
+ xfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork), 0));
for (i = 0; i < be16_to_cpu(dib->bb_numrecs); i++)
scan_lbtree(get_unaligned_be64(&pp[i]),
be16_to_cpu(dib->bb_level), scanfunc_bmap, extmapp,
XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
/* verify agf values before proceeding */
- if (be32_to_cpu(agf->agf_flfirst) >= libxfs_agfl_size(mp) ||
- be32_to_cpu(agf->agf_fllast) >= libxfs_agfl_size(mp)) {
+ if (be32_to_cpu(agf->agf_flfirst) >= xfs_agfl_size(mp) ||
+ be32_to_cpu(agf->agf_fllast) >= xfs_agfl_size(mp)) {
dbprintf(_("agf %d freelist blocks bad, skipping "
"freelist scan\n"), seqno);
pop_cur();
return;
}
- libxfs_agfl_walk(mp, agf, iocur_top->bp, scan_agfl, &seqno);
+ xfs_agfl_walk(mp, agf, iocur_top->bp, scan_agfl, &seqno);
pop_cur();
}
if (agno == end_ag)
high.rm_startblock = XFS_FSB_TO_AGBNO(mp, end_fsb);
- error = -libxfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
+ error = -xfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
if (error) {
dbprintf(_("Error %d while reading AGF.\n"), error);
return;
}
- bt_cur = libxfs_rmapbt_init_cursor(mp, NULL, agbp, agno);
+ bt_cur = xfs_rmapbt_init_cursor(mp, NULL, agbp, agno);
if (!bt_cur) {
- libxfs_buf_relse(agbp);
+ xfs_buf_relse(agbp);
dbprintf(_("Not enough memory.\n"));
return;
}
info.agno = agno;
- error = -libxfs_rmap_query_range(bt_cur, &low, &high,
+ error = -xfs_rmap_query_range(bt_cur, &low, &high,
fsmap_fn, &info);
if (error) {
- libxfs_btree_del_cursor(bt_cur, XFS_BTREE_ERROR);
- libxfs_buf_relse(agbp);
+ xfs_btree_del_cursor(bt_cur, XFS_BTREE_ERROR);
+ xfs_buf_relse(agbp);
dbprintf(_("Error %d while querying fsmap btree.\n"),
error);
return;
}
- libxfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
- libxfs_buf_relse(agbp);
+ xfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
+ xfs_buf_relse(agbp);
if (agno == start_ag)
low.rm_startblock = 0;
{
xfs_dahash_t hashval;
- hashval = libxfs_da_hashname((unsigned char *)argv[1], (int)strlen(argv[1]));
+ hashval = xfs_da_hashname((unsigned char *)argv[1], (int)strlen(argv[1]));
dbprintf("0x%x\n", hashval);
return 0;
}
{
struct xfs_fsop_geom geo;
- libxfs_fs_geometry(&mp->m_sb, &geo, XFS_FS_GEOM_MAX_STRUCT_VER);
+ xfs_fs_geometry(&mp->m_sb, &geo, XFS_FS_GEOM_MAX_STRUCT_VER);
xfs_report_geom(&geo, fsdevice, x.logname, x.rtname);
return 0;
}
xfs_extlen_t length = 0;
int error;
- error = -libxfs_refcountbt_calc_reserves(mp, NULL, agno, &ask, &used);
+ error = -xfs_refcountbt_calc_reserves(mp, NULL, agno, &ask, &used);
if (error)
xfrog_perror(error, "refcountbt");
- error = -libxfs_finobt_calc_reserves(mp, NULL, agno, &ask, &used);
+ error = -xfs_finobt_calc_reserves(mp, NULL, agno, &ask, &used);
if (error)
xfrog_perror(error, "finobt");
- error = -libxfs_rmapbt_calc_reserves(mp, NULL, agno, &ask, &used);
+ error = -xfs_rmapbt_calc_reserves(mp, NULL, agno, &ask, &used);
if (error)
xfrog_perror(error, "rmapbt");
- error = -libxfs_read_agf(mp, NULL, agno, 0, &bp);
+ error = -xfs_read_agf(mp, NULL, agno, 0, &bp);
if (error)
xfrog_perror(error, "AGF");
agf = bp->b_addr;
length = be32_to_cpu(agf->agf_length);
free = be32_to_cpu(agf->agf_freeblks) +
be32_to_cpu(agf->agf_flcount);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
printf("AG %d: length: %u free: %u reserved: %u used: %u",
agno, length, free, ask, used);
*/
memset(&xmount, 0, sizeof(struct xfs_mount));
libxfs_buftarg_init(&xmount, x.ddev, x.logdev, x.rtdev);
- error = -libxfs_buf_read_uncached(xmount.m_ddev_targp, XFS_SB_DADDR,
+ error = -xfs_buf_read_uncached(xmount.m_ddev_targp, XFS_SB_DADDR,
1 << (XFS_MAX_SECTORSIZE_LOG - BBSHIFT), 0, &bp, NULL);
if (error) {
fprintf(stderr, _("%s: %s is invalid (cannot read first 512 "
}
/* copy SB from buffer to in-core, converting architecture as we go */
- libxfs_sb_from_disk(&xmount.m_sb, bp->b_addr);
- libxfs_buf_relse(bp);
+ xfs_sb_from_disk(&xmount.m_sb, bp->b_addr);
+ xfs_buf_relse(bp);
sbp = &xmount.m_sb;
if (sbp->sb_magicnum != XFS_SB_MAGIC) {
*/
if (sbp->sb_rootino != NULLFSINO &&
xfs_sb_version_haslazysbcount(&mp->m_sb)) {
- int error = -libxfs_initialize_perag_data(mp, sbp->sb_agcount);
+ int error = -xfs_initialize_perag_data(mp, sbp->sb_agcount);
if (error) {
fprintf(stderr,
_("%s: cannot init perag data (%d). Continuing anyway.\n"),
iocur_top->dirino = ino;
if (xfs_sb_version_hascrc(&mp->m_sb)) {
- iocur_top->ino_crc_ok = libxfs_verify_cksum((char *)dip,
+ iocur_top->ino_crc_ok = xfs_verify_cksum((char *)dip,
mp->m_sb.sb_inodesize,
XFS_DINODE_CRC_OFF);
if (!iocur_top->ino_crc_ok)
ASSERT(iocur_top->ino_buf);
ASSERT(iocur_top->bp == bp);
- libxfs_dinode_calc_crc(mp, iocur_top->data);
+ xfs_dinode_calc_crc(mp, iocur_top->data);
iocur_top->ino_crc_ok = 1;
}
return;
}
if (iocur_top->bp) {
- libxfs_buf_relse(iocur_top->bp);
+ xfs_buf_relse(iocur_top->bp);
iocur_top->bp = NULL;
}
if (iocur_top->bbmap) {
{
int ret;
- ret = -libxfs_bwrite(iocur_top->bp);
+ ret = -xfs_bwrite(iocur_top->bp);
if (ret != 0)
dbprintf(_("write error: %s\n"), strerror(ret));
{
int ret;
- ret = -libxfs_bwrite(iocur_top->bp);
+ ret = -xfs_bwrite(iocur_top->bp);
if (ret != 0)
dbprintf(_("write error: %s\n"), strerror(ret));
/* If we didn't write the crc automatically, re-check inode validity */
if (xfs_sb_version_hascrc(&mp->m_sb) &&
skip_crc && iocur_top->ino_buf) {
- iocur_top->ino_crc_ok = libxfs_verify_cksum(iocur_top->data,
+ iocur_top->ino_crc_ok = xfs_verify_cksum(iocur_top->data,
mp->m_sb.sb_inodesize,
XFS_DINODE_CRC_OFF);
}
if (!iocur_top->bbmap)
return;
memcpy(iocur_top->bbmap, bbmap, sizeof(struct bbmap));
- error = -libxfs_buf_read_map(mp->m_ddev_targp, bbmap->b,
+ error = -xfs_buf_read_map(mp->m_ddev_targp, bbmap->b,
bbmap->nmaps, LIBXFS_READBUF_SALVAGE, &bp,
ops);
} else {
- error = -libxfs_buf_read(mp->m_ddev_targp, blknum, len,
+ error = -xfs_buf_read(mp->m_ddev_targp, blknum, len,
LIBXFS_READBUF_SALVAGE, &bp, ops);
iocur_top->bbmap = NULL;
}
end_res = (struct xfs_trans_res *)(M_RES(mp) + 1);
for (i = 0; res < end_res; i++, res++)
print_logres(i, res);
- libxfs_log_get_max_trans_res(mp, &resv);
+ xfs_log_get_max_trans_res(mp, &resv);
print_logres(-1, &resv);
return 0;
*first ^= 0x10;
ASSERT(!is_invalid_char(*first));
}
- ASSERT(libxfs_da_hashname(name, name_len) == hash);
+ ASSERT(xfs_da_hashname(name, name_len) == hash);
}
/*
/* Obfuscate the name (if possible) */
- hash = libxfs_da_hashname(name, namelen);
+ hash = xfs_da_hashname(name, namelen);
obfuscate_name(hash, namelen, name);
/*
namelen = ino_dir_size - ((char *)&sfep->name[0] -
(char *)sfp);
} else if ((char *)sfep - (char *)sfp +
- libxfs_dir2_sf_entsize(mp, sfp, sfep->namelen) >
+ xfs_dir2_sf_entsize(mp, sfp, sfep->namelen) >
ino_dir_size) {
if (show_warnings)
print_warning("entry length in dir inode %llu "
if (obfuscate)
generate_obfuscated_name(
- libxfs_dir2_sf_get_ino(mp, sfp, sfep),
+ xfs_dir2_sf_get_ino(mp, sfp, sfep),
namelen, &sfep->name[0]);
sfep = (xfs_dir2_sf_entry_t *)((char *)sfep +
- libxfs_dir2_sf_entsize(mp, sfp, namelen));
+ xfs_dir2_sf_entsize(mp, sfp, namelen));
}
/* zero stale data in rest of space in data fork, if any */
if (!slash) {
/* last (or single) component */
namelen = strnlen((char *)comp, len);
- hash = libxfs_da_hashname(comp, namelen);
+ hash = xfs_da_hashname(comp, namelen);
obfuscate_name(hash, namelen, comp);
break;
}
len--;
continue;
}
- hash = libxfs_da_hashname(comp, namelen);
+ hash = xfs_da_hashname(comp, namelen);
obfuscate_name(hash, namelen, comp);
comp += namelen + 1;
len -= namelen + 1;
return;
free = (struct xfs_dir2_free *)block;
- libxfs_dir2_free_hdr_from_disk(mp, &freehdr, free);
+ xfs_dir2_free_hdr_from_disk(mp, &freehdr, free);
switch (freehdr.magic) {
case XFS_DIR2_FREE_MAGIC:
/* Yes, this works for dir2 & dir3. Difference is padding. */
leaf = (struct xfs_dir2_leaf *)block;
- libxfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
+ xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
switch (leafhdr.magic) {
case XFS_DIR2_LEAF1_MAGIC:
}
dep = (xfs_dir2_data_entry_t *)ptr;
- length = libxfs_dir2_data_entsize(mp, dep->namelen);
+ length = xfs_dir2_data_entsize(mp, dep->namelen);
if (dir_offset + length > end_of_data ||
ptr + length > endptr) {
(long long)cur_ino);
return;
}
- if (be16_to_cpu(*libxfs_dir2_data_entry_tag_p(mp, dep)) !=
+ if (be16_to_cpu(*xfs_dir2_data_entry_tag_p(mp, dep)) !=
dir_offset)
return;
if (zero_stale_data) {
/* 1 byte for ftype; don't bother with conditional */
int zlen =
- (char *)libxfs_dir2_data_entry_tag_p(mp, dep) -
+ (char *)xfs_dir2_data_entry_tag_p(mp, dep) -
(char *)&dep->name[dep->namelen] - 1;
if (zlen > 0) {
memset(&dep->name[dep->namelen] + 1, 0, zlen);
struct xfs_da3_icnode_hdr hdr;
int used;
- libxfs_da3_node_hdr_from_disk(mp, &hdr, node);
+ xfs_da3_node_hdr_from_disk(mp, &hdr, node);
switch (btype) {
case TYP_DIR2:
used = mp->m_dir_geo->node_hdr_size;
nrecs, itype);
}
- maxrecs = libxfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork), 0);
+ maxrecs = xfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork), 0);
if (nrecs > maxrecs) {
if (show_warnings)
print_warning("invalid numrecs (%u) in inode %lld %s "
/* we only care about crc recalculation if we will modify the inode. */
if (obfuscate || zero_stale_data) {
- crc_was_ok = libxfs_verify_cksum((char *)dip,
+ crc_was_ok = xfs_verify_cksum((char *)dip,
mp->m_sb.sb_inodesize,
offsetof(struct xfs_dinode, di_crc));
}
need_new_crc = 1;
if (crc_was_ok && need_new_crc)
- libxfs_dinode_calc_crc(mp, dip);
+ xfs_dinode_calc_crc(mp, dip);
return success;
}
i = be32_to_cpu(agf->agf_fllast);
for (;;) {
- if (++i == libxfs_agfl_size(mp))
+ if (++i == xfs_agfl_size(mp))
i = 0;
if (i == be32_to_cpu(agf->agf_flfirst))
break;
return 0;
}
- libxfs_sb_from_disk(sb, iocur_top->data);
+ xfs_sb_from_disk(sb, iocur_top->data);
if (sb->sb_magicnum != XFS_SB_MAGIC) {
dbprintf(_("bad sb magic # %#x in AG %u\n"),
uuid_equal(uuid, &mp->m_sb.sb_meta_uuid)) {
memset(&tsb.sb_meta_uuid, 0, sizeof(uuid_t));
/* Write those zeros now; it's ignored once we clear the flag */
- libxfs_sb_to_disk(iocur_top->data, &tsb);
+ xfs_sb_to_disk(iocur_top->data, &tsb);
mp->m_sb.sb_features_incompat &=
~XFS_SB_FEAT_INCOMPAT_META_UUID;
tsb.sb_features_incompat &= ~XFS_SB_FEAT_INCOMPAT_META_UUID;
write:
memcpy(&tsb.sb_uuid, uuid, sizeof(uuid_t));
- libxfs_sb_to_disk(iocur_top->data, &tsb);
+ xfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return uuid;
}
memset(&tsb.sb_fname, 0, sizeof(tsb.sb_fname));
memcpy(&tsb.sb_fname, label, len);
memcpy(&lbl[0], &tsb.sb_fname, sizeof(tsb.sb_fname));
- libxfs_sb_to_disk(iocur_top->data, &tsb);
+ xfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return &lbl[0];
}
tsb.sb_versionnum = version;
tsb.sb_features2 = features;
tsb.sb_bad_features2 = features;
- libxfs_sb_to_disk(iocur_top->data, &tsb);
+ xfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return 1;
}
* For prefetch support, the top half of the range starts at
* CACHE_PREFETCH_PRIORITY and everytime the buffer is fetched and is at or
* above this priority level, it is reduced to below this level (refer to
- * libxfs_buf_get).
+ * xfs_buf_get).
*
* If we have dirty nodes, we can't recycle them until they've been cleaned. To
* keep these out of the reclaimable lists (as there can be lots of them) give
#ifndef __LIBXFS_H__
#define __LIBXFS_H__
-#include "libxfs_api_defs.h"
#include "platform_defs.h"
#include "xfs.h"
/* Shared utility routines */
-extern int libxfs_alloc_file_space (struct xfs_inode *, xfs_off_t,
+extern int xfs_alloc_file_space (struct xfs_inode *, xfs_off_t,
xfs_off_t, int, int);
/* XXX: this is messy and needs fixing */
/* XXX: this is clearly a bug - a shared header needs to export this */
/* xfs_rtalloc.c */
-int libxfs_rtfree_extent(struct xfs_trans *, xfs_rtblock_t, xfs_extlen_t);
-bool libxfs_verify_rtbno(struct xfs_mount *mp, xfs_rtblock_t rtbno);
+int xfs_rtfree_extent(struct xfs_trans *, xfs_rtblock_t, xfs_extlen_t);
+bool xfs_verify_rtbno(struct xfs_mount *mp, xfs_rtblock_t rtbno);
#include "xfs_attr.h"
gid_t cr_gid;
} cred_t;
-extern int libxfs_inode_alloc (struct xfs_trans **, struct xfs_inode *,
+extern int xfs_inode_alloc (struct xfs_trans **, struct xfs_inode *,
mode_t, nlink_t, xfs_dev_t, struct cred *,
struct fsxattr *, struct xfs_inode **);
-extern void libxfs_trans_inode_alloc_buf (struct xfs_trans *,
+extern void xfs_trans_inode_alloc_buf (struct xfs_trans *,
struct xfs_buf *);
-extern void libxfs_trans_ichgtime(struct xfs_trans *,
+extern void xfs_trans_ichgtime(struct xfs_trans *,
struct xfs_inode *, int);
extern int libxfs_iflush_int (struct xfs_inode *, struct xfs_buf *);
extern struct timespec64 current_time(struct inode *inode);
/* Inode Cache Interfaces */
-extern bool libxfs_inode_verify_forks(struct xfs_inode *ip);
+extern bool xfs_inode_verify_forks(struct xfs_inode *ip);
extern int libxfs_iget(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
uint, struct xfs_inode **,
struct xfs_ifork_ops *);
void xfs_trans_init(struct xfs_mount *);
int xfs_trans_roll(struct xfs_trans **);
-int libxfs_trans_alloc(struct xfs_mount *mp, struct xfs_trans_res *resp,
+int xfs_trans_alloc(struct xfs_mount *mp, struct xfs_trans_res *resp,
uint blocks, uint rtextents, uint flags,
struct xfs_trans **tpp);
-int libxfs_trans_alloc_rollable(struct xfs_mount *mp, uint blocks,
+int xfs_trans_alloc_rollable(struct xfs_mount *mp, uint blocks,
struct xfs_trans **tpp);
-int libxfs_trans_alloc_empty(struct xfs_mount *mp, struct xfs_trans **tpp);
-int libxfs_trans_commit(struct xfs_trans *);
-void libxfs_trans_cancel(struct xfs_trans *);
+int xfs_trans_alloc_empty(struct xfs_mount *mp, struct xfs_trans **tpp);
+int xfs_trans_commit(struct xfs_trans *);
+void xfs_trans_cancel(struct xfs_trans *);
/* cancel dfops associated with a transaction */
void xfs_defer_cancel(struct xfs_trans *);
-struct xfs_buf *libxfs_trans_getsb(struct xfs_trans *, struct xfs_mount *);
+struct xfs_buf *xfs_trans_getsb(struct xfs_trans *, struct xfs_mount *);
-void libxfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *, uint);
-void libxfs_trans_log_inode (struct xfs_trans *, struct xfs_inode *,
+void xfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *, uint);
+void xfs_trans_log_inode (struct xfs_trans *, struct xfs_inode *,
uint);
-int libxfs_trans_roll_inode (struct xfs_trans **, struct xfs_inode *);
-
-void libxfs_trans_brelse(struct xfs_trans *, struct xfs_buf *);
-void libxfs_trans_binval(struct xfs_trans *, struct xfs_buf *);
-void libxfs_trans_bjoin(struct xfs_trans *, struct xfs_buf *);
-void libxfs_trans_bhold(struct xfs_trans *, struct xfs_buf *);
-void libxfs_trans_bhold_release(struct xfs_trans *, struct xfs_buf *);
-void libxfs_trans_dirty_buf(struct xfs_trans *, struct xfs_buf *);
-void libxfs_trans_log_buf(struct xfs_trans *, struct xfs_buf *,
+int xfs_trans_roll_inode (struct xfs_trans **, struct xfs_inode *);
+
+void xfs_trans_brelse(struct xfs_trans *, struct xfs_buf *);
+void xfs_trans_binval(struct xfs_trans *, struct xfs_buf *);
+void xfs_trans_bjoin(struct xfs_trans *, struct xfs_buf *);
+void xfs_trans_bhold(struct xfs_trans *, struct xfs_buf *);
+void xfs_trans_bhold_release(struct xfs_trans *, struct xfs_buf *);
+void xfs_trans_dirty_buf(struct xfs_trans *, struct xfs_buf *);
+void xfs_trans_log_buf(struct xfs_trans *, struct xfs_buf *,
uint, uint);
-bool libxfs_trans_ordered_buf(xfs_trans_t *, struct xfs_buf *);
+bool xfs_trans_ordered_buf(xfs_trans_t *, struct xfs_buf *);
-int libxfs_trans_get_buf_map(struct xfs_trans *tp, struct xfs_buftarg *btp,
+int xfs_trans_get_buf_map(struct xfs_trans *tp, struct xfs_buftarg *btp,
struct xfs_buf_map *map, int nmaps, xfs_buf_flags_t flags,
struct xfs_buf **bpp);
-int libxfs_trans_read_buf_map(struct xfs_mount *mp, struct xfs_trans *tp,
+int xfs_trans_read_buf_map(struct xfs_mount *mp, struct xfs_trans *tp,
struct xfs_buftarg *btp,
struct xfs_buf_map *map, int nmaps,
xfs_buf_flags_t flags, struct xfs_buf **bpp,
const struct xfs_buf_ops *ops);
static inline int
-libxfs_trans_get_buf(
+xfs_trans_get_buf(
struct xfs_trans *tp,
struct xfs_buftarg *btp,
xfs_daddr_t blkno,
{
DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
- return libxfs_trans_get_buf_map(tp, btp, &map, 1, flags, bpp);
+ return xfs_trans_get_buf_map(tp, btp, &map, 1, flags, bpp);
}
static inline int
-libxfs_trans_read_buf(
+xfs_trans_read_buf(
struct xfs_mount *mp,
struct xfs_trans *tp,
struct xfs_buftarg *btp,
const struct xfs_buf_ops *ops)
{
DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
- return libxfs_trans_read_buf_map(mp, tp, btp, &map, 1, flags, bpp, ops);
+ return xfs_trans_read_buf_map(mp, tp, btp, &map, 1, flags, bpp, ops);
}
#endif /* __XFS_TRANS_H__ */
/* The last inode number in use */
last_ino = ireq->inumbers[lastgrp].xi_startino +
- libxfs_highbit64(ireq->inumbers[lastgrp].xi_allocmask);
+ xfs_highbit64(ireq->inumbers[lastgrp].xi_allocmask);
out:
free(ireq);
xfs_trans_resv.h \
xfs_trans_space.h \
libxfs_io.h \
- libxfs_api_defs.h \
init.h \
libxfs_priv.h \
xfs_dir2_priv.h
cache->c_misses = 0;
cache->c_maxcount = maxcount;
cache->c_hashsize = hashsize;
- cache->c_hashshift = libxfs_highbit32(hashsize);
+ cache->c_hashshift = xfs_highbit32(hashsize);
cache->hash = cache_operations->hash;
cache->alloc = cache_operations->alloc;
cache->flush = cache_operations->flush;
(unsigned long long) mp->m_sb.sb_rblocks);
return -1;
}
- error = libxfs_buf_read(mp->m_rtdev, d - XFS_FSB_TO_BB(mp, 1),
+ error = xfs_buf_read(mp->m_rtdev, d - XFS_FSB_TO_BB(mp, 1),
XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
if (error) {
fprintf(stderr, _("%s: realtime size check failed\n"),
progname);
return -1;
}
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 0;
}
return mp;
/* device size checks must pass unless we're a debugger. */
- error = libxfs_buf_read(mp->m_dev, d - XFS_FSS_TO_BB(mp, 1),
+ error = xfs_buf_read(mp->m_dev, d - XFS_FSS_TO_BB(mp, 1),
XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
if (error) {
fprintf(stderr, _("%s: data size check failed\n"), progname);
if (!debugger)
return NULL;
} else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
if (mp->m_logdev_targp->dev &&
mp->m_logdev_targp->dev != mp->m_ddev_targp->dev) {
d = (xfs_daddr_t) XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks ||
- libxfs_buf_read(mp->m_logdev_targp,
+ xfs_buf_read(mp->m_logdev_targp,
d - XFS_FSB_TO_BB(mp, 1), XFS_FSB_TO_BB(mp, 1),
0, &bp, NULL)) {
fprintf(stderr, _("%s: log size checks failed\n"),
return NULL;
}
if (bp)
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
/* Initialize realtime fields in the mount structure */
* read the first one and let the user know to check the geometry.
*/
if (sbp->sb_agcount > 1000000) {
- error = libxfs_buf_read(mp->m_dev,
+ error = xfs_buf_read(mp->m_dev,
XFS_AG_DADDR(mp, sbp->sb_agcount - 1, 0), 1,
0, &bp, NULL);
if (error) {
progname);
sbp->sb_agcount = 1;
} else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
error = libxfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
- * All Rights Reserved.
- */
-
-#ifndef __LIBXFS_API_DEFS_H__
-#define __LIBXFS_API_DEFS_H__
-
-/*
- * This file defines all the kernel based functions we expose to userspace
- * via the libxfs_* namespace. This is kept in a separate header file so
- * it can be included in both the internal and external libxfs header files
- * without introducing any depenencies between the two.
- */
-#define LIBXFS_ATTR_ROOT XFS_ATTR_ROOT
-#define LIBXFS_ATTR_SECURE XFS_ATTR_SECURE
-
-#define xfs_agfl_size libxfs_agfl_size
-#define xfs_agfl_walk libxfs_agfl_walk
-
-#define xfs_ag_init_headers libxfs_ag_init_headers
-
-#define xfs_alloc_ag_max_usable libxfs_alloc_ag_max_usable
-#define xfs_allocbt_maxrecs libxfs_allocbt_maxrecs
-#define xfs_alloc_fix_freelist libxfs_alloc_fix_freelist
-#define xfs_alloc_min_freelist libxfs_alloc_min_freelist
-#define xfs_alloc_read_agf libxfs_alloc_read_agf
-
-#define xfs_attr_get libxfs_attr_get
-#define xfs_attr_leaf_newentsize libxfs_attr_leaf_newentsize
-#define xfs_attr_namecheck libxfs_attr_namecheck
-#define xfs_attr_set libxfs_attr_set
-
-#define xfs_bmapi_read libxfs_bmapi_read
-#define xfs_bmapi_write libxfs_bmapi_write
-#define xfs_bmap_last_offset libxfs_bmap_last_offset
-#define xfs_bmbt_maxrecs libxfs_bmbt_maxrecs
-#define xfs_bmdr_maxrecs libxfs_bmdr_maxrecs
-
-#define xfs_btree_del_cursor libxfs_btree_del_cursor
-#define xfs_btree_init_block libxfs_btree_init_block
-#define xfs_buf_delwri_submit libxfs_buf_delwri_submit
-#define xfs_buf_get libxfs_buf_get
-#define xfs_buf_get_uncached libxfs_buf_get_uncached
-#define xfs_buf_read libxfs_buf_read
-#define xfs_buf_read_uncached libxfs_buf_read_uncached
-#define xfs_buf_relse libxfs_buf_relse
-#define xfs_bunmapi libxfs_bunmapi
-#define xfs_bwrite libxfs_bwrite
-#define xfs_calc_dquots_per_chunk libxfs_calc_dquots_per_chunk
-#define xfs_da3_node_hdr_from_disk libxfs_da3_node_hdr_from_disk
-#define xfs_da_get_buf libxfs_da_get_buf
-#define xfs_da_hashname libxfs_da_hashname
-#define xfs_da_read_buf libxfs_da_read_buf
-#define xfs_da_shrink_inode libxfs_da_shrink_inode
-#define xfs_default_ifork_ops libxfs_default_ifork_ops
-#define xfs_defer_cancel libxfs_defer_cancel
-#define xfs_defer_finish libxfs_defer_finish
-#define xfs_dinode_calc_crc libxfs_dinode_calc_crc
-#define xfs_dinode_good_version libxfs_dinode_good_version
-#define xfs_dinode_verify libxfs_dinode_verify
-
-#define xfs_dir2_data_bestfree_p libxfs_dir2_data_bestfree_p
-#define xfs_dir2_data_entry_tag_p libxfs_dir2_data_entry_tag_p
-#define xfs_dir2_data_entsize libxfs_dir2_data_entsize
-#define xfs_dir2_data_freescan libxfs_dir2_data_freescan
-#define xfs_dir2_data_get_ftype libxfs_dir2_data_get_ftype
-#define xfs_dir2_data_log_entry libxfs_dir2_data_log_entry
-#define xfs_dir2_data_log_header libxfs_dir2_data_log_header
-#define xfs_dir2_data_make_free libxfs_dir2_data_make_free
-#define xfs_dir2_data_put_ftype libxfs_dir2_data_put_ftype
-#define xfs_dir2_data_use_free libxfs_dir2_data_use_free
-#define xfs_dir2_free_hdr_from_disk libxfs_dir2_free_hdr_from_disk
-#define xfs_dir2_hashname libxfs_dir2_hashname
-#define xfs_dir2_isblock libxfs_dir2_isblock
-#define xfs_dir2_isleaf libxfs_dir2_isleaf
-#define xfs_dir2_leaf_hdr_from_disk libxfs_dir2_leaf_hdr_from_disk
-#define xfs_dir2_namecheck libxfs_dir2_namecheck
-#define xfs_dir2_sf_entsize libxfs_dir2_sf_entsize
-#define xfs_dir2_sf_get_ftype libxfs_dir2_sf_get_ftype
-#define xfs_dir2_sf_get_ino libxfs_dir2_sf_get_ino
-#define xfs_dir2_sf_get_parent_ino libxfs_dir2_sf_get_parent_ino
-#define xfs_dir2_sf_nextentry libxfs_dir2_sf_nextentry
-#define xfs_dir2_sf_put_ftype libxfs_dir2_sf_put_ftype
-#define xfs_dir2_sf_put_ino libxfs_dir2_sf_put_ino
-#define xfs_dir2_sf_put_parent_ino libxfs_dir2_sf_put_parent_ino
-#define xfs_dir2_shrink_inode libxfs_dir2_shrink_inode
-
-#define xfs_dir_createname libxfs_dir_createname
-#define xfs_dir_init libxfs_dir_init
-#define xfs_dir_ino_validate libxfs_dir_ino_validate
-#define xfs_dir_lookup libxfs_dir_lookup
-#define xfs_dir_replace libxfs_dir_replace
-
-#define xfs_dqblk_repair libxfs_dqblk_repair
-#define xfs_dquot_verify libxfs_dquot_verify
-
-#define xfs_finobt_calc_reserves libxfs_finobt_calc_reserves
-#define xfs_free_extent libxfs_free_extent
-#define xfs_fs_geometry libxfs_fs_geometry
-#define xfs_highbit32 libxfs_highbit32
-#define xfs_highbit64 libxfs_highbit64
-#define xfs_ialloc_calc_rootino libxfs_ialloc_calc_rootino
-#define xfs_idata_realloc libxfs_idata_realloc
-#define xfs_idestroy_fork libxfs_idestroy_fork
-#define xfs_iext_lookup_extent libxfs_iext_lookup_extent
-#define xfs_initialize_perag_data libxfs_initialize_perag_data
-#define xfs_init_local_fork libxfs_init_local_fork
-
-#define xfs_inobt_maxrecs libxfs_inobt_maxrecs
-#define xfs_inode_from_disk libxfs_inode_from_disk
-#define xfs_inode_to_disk libxfs_inode_to_disk
-#define xfs_inode_validate_cowextsize libxfs_inode_validate_cowextsize
-#define xfs_inode_validate_extsize libxfs_inode_validate_extsize
-
-#define xfs_iread_extents libxfs_iread_extents
-#define xfs_log_calc_minimum_size libxfs_log_calc_minimum_size
-#define xfs_log_get_max_trans_res libxfs_log_get_max_trans_res
-#define xfs_log_sb libxfs_log_sb
-#define xfs_mode_to_ftype libxfs_mode_to_ftype
-#define xfs_perag_get libxfs_perag_get
-#define xfs_perag_put libxfs_perag_put
-#define xfs_prealloc_blocks libxfs_prealloc_blocks
-
-#define xfs_read_agf libxfs_read_agf
-#define xfs_refc_block libxfs_refc_block
-#define xfs_refcountbt_calc_reserves libxfs_refcountbt_calc_reserves
-#define xfs_refcountbt_init_cursor libxfs_refcountbt_init_cursor
-#define xfs_refcountbt_maxrecs libxfs_refcountbt_maxrecs
-#define xfs_refcount_get_rec libxfs_refcount_get_rec
-#define xfs_refcount_lookup_le libxfs_refcount_lookup_le
-
-#define xfs_rmap_alloc libxfs_rmap_alloc
-#define xfs_rmapbt_calc_reserves libxfs_rmapbt_calc_reserves
-#define xfs_rmapbt_init_cursor libxfs_rmapbt_init_cursor
-#define xfs_rmapbt_maxrecs libxfs_rmapbt_maxrecs
-#define xfs_rmap_compare libxfs_rmap_compare
-#define xfs_rmap_get_rec libxfs_rmap_get_rec
-#define xfs_rmap_irec_offset_pack libxfs_rmap_irec_offset_pack
-#define xfs_rmap_irec_offset_unpack libxfs_rmap_irec_offset_unpack
-#define xfs_rmap_lookup_le libxfs_rmap_lookup_le
-#define xfs_rmap_lookup_le_range libxfs_rmap_lookup_le_range
-#define xfs_rmap_query_range libxfs_rmap_query_range
-
-#define xfs_rtfree_extent libxfs_rtfree_extent
-#define xfs_sb_from_disk libxfs_sb_from_disk
-#define xfs_sb_quota_from_disk libxfs_sb_quota_from_disk
-#define xfs_sb_read_secondary libxfs_sb_read_secondary
-#define xfs_sb_to_disk libxfs_sb_to_disk
-#define xfs_symlink_blocks libxfs_symlink_blocks
-#define xfs_symlink_hdr_ok libxfs_symlink_hdr_ok
-
-#define xfs_trans_add_item libxfs_trans_add_item
-#define xfs_trans_alloc_empty libxfs_trans_alloc_empty
-#define xfs_trans_alloc libxfs_trans_alloc
-#define xfs_trans_bhold libxfs_trans_bhold
-#define xfs_trans_bhold_release libxfs_trans_bhold_release
-#define xfs_trans_binval libxfs_trans_binval
-#define xfs_trans_bjoin libxfs_trans_bjoin
-#define xfs_trans_brelse libxfs_trans_brelse
-#define xfs_trans_cancel libxfs_trans_cancel
-#define xfs_trans_commit libxfs_trans_commit
-#define xfs_trans_del_item libxfs_trans_del_item
-#define xfs_trans_dirty_buf libxfs_trans_dirty_buf
-#define xfs_trans_get_buf libxfs_trans_get_buf
-#define xfs_trans_get_buf_map libxfs_trans_get_buf_map
-#define xfs_trans_getsb libxfs_trans_getsb
-#define xfs_trans_ichgtime libxfs_trans_ichgtime
-#define xfs_trans_ijoin libxfs_trans_ijoin
-#define xfs_trans_init libxfs_trans_init
-#define xfs_trans_inode_alloc_buf libxfs_trans_inode_alloc_buf
-#define xfs_trans_log_buf libxfs_trans_log_buf
-#define xfs_trans_log_inode libxfs_trans_log_inode
-#define xfs_trans_mod_sb libxfs_trans_mod_sb
-#define xfs_trans_ordered_buf libxfs_trans_ordered_buf
-#define xfs_trans_read_buf libxfs_trans_read_buf
-#define xfs_trans_read_buf_map libxfs_trans_read_buf_map
-#define xfs_trans_resv_calc libxfs_trans_resv_calc
-#define xfs_trans_roll_inode libxfs_trans_roll_inode
-#define xfs_trans_roll libxfs_trans_roll
-
-#define xfs_verify_cksum libxfs_verify_cksum
-#define xfs_verify_dir_ino libxfs_verify_dir_ino
-#define xfs_verify_ino libxfs_verify_ino
-#define xfs_verify_rtbno libxfs_verify_rtbno
-#define xfs_zero_extent libxfs_zero_extent
-
-/* Please keep this list alphabetized. */
-
-#endif /* __LIBXFS_API_DEFS_H__ */
#ifdef XFS_BUF_TRACING
-#define libxfs_buf_read(dev, daddr, len, flags, bpp, ops) \
+#define xfs_buf_read(dev, daddr, len, flags, bpp, ops) \
libxfs_trace_readbuf(__FUNCTION__, __FILE__, __LINE__, \
(dev), (daddr), (len), (flags), (bpp), (ops))
-#define libxfs_buf_read_map(dev, map, nmaps, flags, bpp, ops) \
+#define xfs_buf_read_map(dev, map, nmaps, flags, bpp, ops) \
libxfs_trace_readbuf_map(__FUNCTION__, __FILE__, __LINE__, \
(dev), (map), (nmaps), (flags), (bpp), (ops))
#define libxfs_buf_mark_dirty(buf) \
libxfs_trace_dirtybuf(__FUNCTION__, __FILE__, __LINE__, \
(buf))
-#define libxfs_buf_get(dev, daddr, len, bpp) \
+#define xfs_buf_get(dev, daddr, len, bpp) \
libxfs_trace_getbuf(__FUNCTION__, __FILE__, __LINE__, \
(dev), (daddr), (len), (bpp))
-#define libxfs_buf_get_map(dev, map, nmaps, flags, bpp) \
+#define xfs_buf_get_map(dev, map, nmaps, flags, bpp) \
libxfs_trace_getbuf_map(__FUNCTION__, __FILE__, __LINE__, \
(dev), (map), (nmaps), (flags), (bpp))
-#define libxfs_buf_relse(buf) \
+#define xfs_buf_relse(buf) \
libxfs_trace_putbuf(__FUNCTION__, __FILE__, __LINE__, (buf))
int libxfs_trace_readbuf(const char *func, const char *file, int line,
#else
-int libxfs_buf_read_map(struct xfs_buftarg *btp, struct xfs_buf_map *maps,
+int xfs_buf_read_map(struct xfs_buftarg *btp, struct xfs_buf_map *maps,
int nmaps, int flags, struct xfs_buf **bpp,
const struct xfs_buf_ops *ops);
void libxfs_buf_mark_dirty(struct xfs_buf *bp);
-int libxfs_buf_get_map(struct xfs_buftarg *btp, struct xfs_buf_map *maps,
+int xfs_buf_get_map(struct xfs_buftarg *btp, struct xfs_buf_map *maps,
int nmaps, int flags, struct xfs_buf **bpp);
-void libxfs_buf_relse(struct xfs_buf *bp);
+void xfs_buf_relse(struct xfs_buf *bp);
static inline int
-libxfs_buf_get(
+xfs_buf_get(
struct xfs_buftarg *target,
xfs_daddr_t blkno,
size_t numblks,
{
DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
- return libxfs_buf_get_map(target, &map, 1, 0, bpp);
+ return xfs_buf_get_map(target, &map, 1, 0, bpp);
}
static inline int
-libxfs_buf_read(
+xfs_buf_read(
struct xfs_buftarg *target,
xfs_daddr_t blkno,
size_t numblks,
{
DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
- return libxfs_buf_read_map(target, &map, 1, flags, bpp, ops);
+ return xfs_buf_read_map(target, &map, 1, flags, bpp, ops);
}
#endif /* XFS_BUF_TRACING */
extern int libxfs_bcache_overflowed(void);
/* Buffer (Raw) Interfaces */
-int libxfs_bwrite(struct xfs_buf *bp);
+int xfs_bwrite(struct xfs_buf *bp);
extern int libxfs_readbufr(struct xfs_buftarg *, xfs_daddr_t, xfs_buf_t *, int, int);
extern int libxfs_readbufr_map(struct xfs_buftarg *, struct xfs_buf *, int);
return 0;
}
-int libxfs_buf_get_uncached(struct xfs_buftarg *targ, size_t bblen, int flags,
+int xfs_buf_get_uncached(struct xfs_buftarg *targ, size_t bblen, int flags,
struct xfs_buf **bpp);
-int libxfs_buf_read_uncached(struct xfs_buftarg *targ, xfs_daddr_t daddr,
+int xfs_buf_read_uncached(struct xfs_buftarg *targ, xfs_daddr_t daddr,
size_t bblen, int flags, struct xfs_buf **bpp,
const struct xfs_buf_ops *ops);
#ifndef __LIBXFS_INTERNAL_XFS_H__
#define __LIBXFS_INTERNAL_XFS_H__
-#include "libxfs_api_defs.h"
#include "platform_defs.h"
#include "xfs.h"
/* XXX: this is clearly a bug - a shared header needs to export this */
/* xfs_rtalloc.c */
-int libxfs_rtfree_extent(struct xfs_trans *, xfs_rtblock_t, xfs_extlen_t);
-bool libxfs_verify_rtbno(struct xfs_mount *mp, xfs_rtblock_t rtbno);
+int xfs_rtfree_extent(struct xfs_trans *, xfs_rtblock_t, xfs_extlen_t);
+bool xfs_verify_rtbno(struct xfs_mount *mp, xfs_rtblock_t rtbno);
struct xfs_rtalloc_rec {
xfs_rtblock_t ar_startext;
struct xfs_rtalloc_rec *rec,
void *priv);
-int libxfs_zero_extent(struct xfs_inode *ip, xfs_fsblock_t start_fsb,
+int xfs_zero_extent(struct xfs_inode *ip, xfs_fsblock_t start_fsb,
xfs_off_t count_fsb);
* outside libxfs clears bp->b_error - very little code even checks it - so the
* libxfs code is tripping on stale errors left by the userspace code.
*
- * We can't clear errors or zero buffer contents in libxfs_buf_get-* like we do
+ * We can't clear errors or zero buffer contents in xfs_buf_get-* like we do
* in the kernel, because those functions are used by the libxfs_readbuf_*
* functions and hence need to leave the buffers unchanged on cache hits. This
* is actually the only way to gather a write error from a libxfs_writebuf()
*
* IOWs, userspace is behaving quite differently to the kernel and as a result
* it leaks errors from reads, invalidations and writes through
- * libxfs_buf_get/libxfs_buf_read.
+ * xfs_buf_get/xfs_buf_read.
*
* The result of this is that until the userspace code outside libxfs is cleaned
* up, functions that release buffers from userspace control (i.e
- * libxfs_writebuf/libxfs_buf_relse) need to zero bp->b_error to prevent
+ * libxfs_writebuf/xfs_buf_relse) need to zero bp->b_error to prevent
* propagation of stale errors into future buffer operations.
*/
#ifdef XFS_BUF_TRACING
-#undef libxfs_buf_read_map
+#undef xfs_buf_read_map
#undef libxfs_writebuf
-#undef libxfs_buf_get_map
+#undef xfs_buf_get_map
-int libxfs_buf_read_map(struct xfs_buftarg *btp,
+int bxfs_buf_read_map(struct xfs_buftarg *btp,
struct xfs_buf_map *maps, int nmaps, int flags,
struct xfs_buf **bpp,
const struct xfs_buf_ops *ops);
int libxfs_writebuf(xfs_buf_t *, int);
-int libxfs_buf_get_map(struct xfs_buftarg *btp,
+int xfs_buf_get_map(struct xfs_buftarg *btp,
struct xfs_buf_map *maps, int nmaps, int flags,
struct xfs_buf **bpp);
-void libxfs_buf_relse(struct xfs_buf *bp);
+void xfs_buf_relse(struct xfs_buf *bp);
#define __add_trace(bp, func, file, line) \
do { \
int error;
DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
- error = libxfs_buf_read_map(btp, &map, 1, flags, bpp, ops);
+ error = xfs_buf_read_map(btp, &map, 1, flags, bpp, ops);
__add_trace(*bpp, func, file, line);
return error;
}
{
int error;
- error = libxfs_buf_read_map(btp, map, nmaps, flags, bpp, ops);
+ error = xfs_buf_read_map(btp, map, nmaps, flags, bpp, ops);
__add_trace(*bpp, func, file, line);
return error;
}
int error;
DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
- error = libxfs_buf_get_map(target, &map, 1, 0, bpp);
+ error = xfs_buf_get_map(target, &map, 1, 0, bpp);
__add_trace(bp, func, file, line);
return error;
}
{
int error;
- error = libxfs_buf_get_map(btp, map, nmaps, flags, bpp);
+ error = xfs_buf_get_map(btp, map, nmaps, flags, bpp);
__add_trace(*bpp, func, file, line);
return error;
}
libxfs_trace_putbuf(const char *func, const char *file, int line, xfs_buf_t *bp)
{
__add_trace(bp, func, file, line);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
{
struct xfs_buf *bp;
- libxfs_buf_read(mp->m_ddev_targp, XFS_SB_DADDR, XFS_FSS_TO_BB(mp, 1),
+ xfs_buf_read(mp->m_ddev_targp, XFS_SB_DADDR, XFS_FSS_TO_BB(mp, 1),
0, &bp, &xfs_sb_buf_ops);
return bp;
}
}
int
-libxfs_buf_get_map(
+xfs_buf_get_map(
struct xfs_buftarg *btp,
struct xfs_buf_map *map,
int nmaps,
}
void
-libxfs_buf_relse(
+xfs_buf_relse(
struct xfs_buf *bp)
{
/*
cache_node_put(libxfs_bcache, &bp->b_node);
else if (--bp->b_node.cn_count == 0) {
if (bp->b_flags & LIBXFS_B_DIRTY)
- libxfs_bwrite(bp);
+ xfs_bwrite(bp);
libxfs_brelse(&bp->b_node);
}
}
}
int
-libxfs_buf_read_map(
+xfs_buf_read_map(
struct xfs_buftarg *btp,
struct xfs_buf_map *map,
int nmaps,
*bpp = bp;
return 0;
err:
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
* and the cache node hash list will be empty to indicate that it's uncached.
*/
int
-libxfs_buf_get_uncached(
+xfs_buf_get_uncached(
struct xfs_buftarg *targ,
size_t bblen,
int flags,
* node hash list will be empty to indicate that it's uncached.
*/
int
-libxfs_buf_read_uncached(
+xfs_buf_read_uncached(
struct xfs_buftarg *targ,
xfs_daddr_t daddr,
size_t bblen,
*bpp = bp;
return 0;
err:
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
}
int
-libxfs_bwrite(
+xfs_bwrite(
struct xfs_buf *bp)
{
int fd = libxfs_device_to_fd(bp->b_target->dev);
b_node);
if (!bp->b_error && bp->b_flags & LIBXFS_B_DIRTY)
- return libxfs_bwrite(bp);
+ return xfs_bwrite(bp);
return bp->b_error;
}
* make sure they're not corrupt.
*/
bool
-libxfs_inode_verify_forks(
+xfs_inode_verify_forks(
struct xfs_inode *ip)
{
struct xfs_ifork *ifp;
}
ip->i_fork_ops = ifork_ops;
- if (!libxfs_inode_verify_forks(ip)) {
+ if (!xfs_inode_verify_forks(ip)) {
libxfs_irele(ip);
return -EFSCORRUPTED;
}
case S_IFREG:
case S_IFDIR:
case S_IFLNK:
- libxfs_idestroy_fork(ip, XFS_DATA_FORK);
+ xfs_idestroy_fork(ip, XFS_DATA_FORK);
break;
}
if (ip->i_afp)
- libxfs_idestroy_fork(ip, XFS_ATTR_FORK);
+ xfs_idestroy_fork(ip, XFS_ATTR_FORK);
if (ip->i_cowfp)
xfs_idestroy_fork(ip, XFS_COW_FORK);
}
list_for_each_entry_safe(bp, n, buffer_list, b_list) {
list_del_init(&bp->b_list);
- error2 = libxfs_bwrite(bp);
+ error2 = xfs_bwrite(bp);
if (!error)
error = error2;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
return error;
bp = list_first_entry(list, struct xfs_buf, b_list);
list_del_init(&bp->b_list);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
}
next, bp);
if (bp) {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
/*
tail_lsn, next, bp);
if (bp) {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
blk += len;
* in the mount structure.
*/
void
-libxfs_trans_init(
+xfs_trans_init(
struct xfs_mount *mp)
{
xfs_trans_resv_calc(mp, &mp->m_resv);
* Add the given log item to the transaction's list of log items.
*/
void
-libxfs_trans_add_item(
+xfs_trans_add_item(
struct xfs_trans *tp,
struct xfs_log_item *lip)
{
* Unlink and free the given descriptor.
*/
void
-libxfs_trans_del_item(
+xfs_trans_del_item(
struct xfs_log_item *lip)
{
clear_bit(XFS_LI_DIRTY, &lip->li_flags);
* chunk we've been working on and get a new transaction to continue.
*/
int
-libxfs_trans_roll(
+xfs_trans_roll(
struct xfs_trans **tpp)
{
struct xfs_trans *trans = *tpp;
}
int
-libxfs_trans_alloc(
+xfs_trans_alloc(
struct xfs_mount *mp,
struct xfs_trans_res *resp,
unsigned int blocks,
* without any dirty data.
*/
int
-libxfs_trans_alloc_empty(
+xfs_trans_alloc_empty(
struct xfs_mount *mp,
struct xfs_trans **tpp)
{
* permanent log reservation flag to avoid blowing asserts.
*/
int
-libxfs_trans_alloc_rollable(
+xfs_trans_alloc_rollable(
struct xfs_mount *mp,
unsigned int blocks,
struct xfs_trans **tpp)
{
- return libxfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, blocks,
+ return xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, blocks,
0, 0, tpp);
}
void
-libxfs_trans_cancel(
+xfs_trans_cancel(
struct xfs_trans *tp)
{
trace_xfs_trans_cancel(tp, _RET_IP_);
* then allocate one for it. Then add the buf item to the transaction.
*/
STATIC void
-_libxfs_trans_bjoin(
+_xfs_trans_bjoin(
struct xfs_trans *tp,
struct xfs_buf *bp,
int reset_recur)
}
void
-libxfs_trans_bjoin(
+xfs_trans_bjoin(
struct xfs_trans *tp,
struct xfs_buf *bp)
{
- _libxfs_trans_bjoin(tp, bp, 0);
+ _xfs_trans_bjoin(tp, bp, 0);
trace_xfs_trans_bjoin(bp->b_log_item);
}
* for this transaction.
*/
void
-libxfs_trans_bhold_release(
+xfs_trans_bhold_release(
xfs_trans_t *tp,
xfs_buf_t *bp)
{
* get_buf() call.
*/
int
-libxfs_trans_get_buf_map(
+xfs_trans_get_buf_map(
struct xfs_trans *tp,
struct xfs_buftarg *target,
struct xfs_buf_map *map,
*bpp = NULL;
if (!tp)
- return libxfs_buf_get_map(target, map, nmaps, 0, bpp);
+ return xfs_buf_get_map(target, map, nmaps, 0, bpp);
/*
* If we find the buffer in the cache with this transaction
return 0;
}
- error = libxfs_buf_get_map(target, map, nmaps, 0, &bp);
+ error = xfs_buf_get_map(target, map, nmaps, 0, &bp);
if (error)
return error;
ASSERT(!bp->b_error);
- _libxfs_trans_bjoin(tp, bp, 1);
+ _xfs_trans_bjoin(tp, bp, 1);
trace_xfs_trans_get_buf(bp->b_log_item);
*bpp = bp;
return 0;
}
xfs_buf_t *
-libxfs_trans_getsb(
+xfs_trans_getsb(
xfs_trans_t *tp,
struct xfs_mount *mp)
{
if (bp == NULL)
return NULL;
- _libxfs_trans_bjoin(tp, bp, 1);
+ _xfs_trans_bjoin(tp, bp, 1);
trace_xfs_trans_getsb(bp->b_log_item);
return bp;
}
int
-libxfs_trans_read_buf_map(
+xfs_trans_read_buf_map(
struct xfs_mount *mp,
struct xfs_trans *tp,
struct xfs_buftarg *target,
*bpp = NULL;
if (tp == NULL)
- return libxfs_buf_read_map(target, map, nmaps, flags, bpp, ops);
+ return xfs_buf_read_map(target, map, nmaps, flags, bpp, ops);
bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
if (bp) {
goto done;
}
- error = libxfs_buf_read_map(target, map, nmaps, flags, &bp, ops);
+ error = xfs_buf_read_map(target, map, nmaps, flags, &bp, ops);
if (error)
return error;
- _libxfs_trans_bjoin(tp, bp, 1);
+ _xfs_trans_bjoin(tp, bp, 1);
done:
trace_xfs_trans_read_buf(bp->b_log_item);
*bpp = bp;
* If the transaction pointer is NULL, this is a normal xfs_buf_relse() call.
*/
void
-libxfs_trans_brelse(
+xfs_trans_brelse(
struct xfs_trans *tp,
struct xfs_buf *bp)
{
ASSERT(bp->b_transp == tp);
if (!tp) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return;
}
xfs_buf_item_put(bip);
bp->b_transp = NULL;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
/*
*/
/* ARGSUSED */
void
-libxfs_trans_bhold(
+xfs_trans_bhold(
xfs_trans_t *tp,
xfs_buf_t *bp)
{
* Mark a buffer dirty in the transaction.
*/
void
-libxfs_trans_dirty_buf(
+xfs_trans_dirty_buf(
struct xfs_trans *tp,
struct xfs_buf *bp)
{
* value of b_blkno.
*/
void
-libxfs_trans_log_buf(
+xfs_trans_log_buf(
struct xfs_trans *tp,
struct xfs_buf *bp,
uint first,
}
void
-libxfs_trans_binval(
+xfs_trans_binval(
xfs_trans_t *tp,
xfs_buf_t *bp)
{
*/
/* ARGSUSED */
void
-libxfs_trans_inode_alloc_buf(
+xfs_trans_inode_alloc_buf(
xfs_trans_t *tp,
xfs_buf_t *bp)
{
* If the buffer is already dirty, trigger the "already logged" return condition.
*/
bool
-libxfs_trans_ordered_buf(
+xfs_trans_ordered_buf(
struct xfs_trans *tp,
struct xfs_buf *bp)
{
bool ret;
ret = test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
- libxfs_trans_log_buf(tp, bp, 0, bp->b_bcount);
+ xfs_trans_log_buf(tp, bp, 0, bp->b_bcount);
return ret;
}
* Originally derived from xfs_trans_mod_sb().
*/
void
-libxfs_trans_mod_sb(
+xfs_trans_mod_sb(
xfs_trans_t *tp,
uint field,
long delta)
if (error) {
fprintf(stderr, _("%s: warning - iflush_int failed (%d)\n"),
progname, error);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto free;
}
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
free:
xfs_inode_item_put(iip);
}
xfs_buf_item_put(bip);
if (hold)
return;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
static void
bip->bli_flags &= ~XFS_BLI_HOLD;
xfs_buf_item_put(bip);
if (!hold)
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
static void
}
int
-libxfs_trans_commit(
+xfs_trans_commit(
struct xfs_trans *tp)
{
return __xfs_trans_commit(tp, false);
VFS_I(ip)->i_version++;
/* Check the inline fork data before we write out. */
- if (!libxfs_inode_verify_forks(ip))
+ if (!xfs_inode_verify_forks(ip))
return -EFSCORRUPTED;
/*
* Originally derived from xfs_alloc_file_space().
*/
int
-libxfs_alloc_file_space(
+xfs_alloc_file_space(
xfs_inode_t *ip,
xfs_off_t offset,
xfs_off_t len,
* other in repair - now there is just the one.
*/
int
-libxfs_inode_alloc(
+xfs_inode_alloc(
xfs_trans_t **tp,
xfs_inode_t *pip,
mode_t mode,
}
int
-libxfs_zero_extent(
+xfs_zero_extent(
struct xfs_inode *ip,
xfs_fsblock_t start_fsb,
xfs_off_t count_fsb)
nbblks += log->l_sectBBsize;
nbblks = round_up(nbblks, log->l_sectBBsize);
- libxfs_buf_get_uncached(log->l_dev, nbblks, 0, &bp);
+ xfs_buf_get_uncached(log->l_dev, nbblks, 0, &bp);
return bp;
}
*new_blk = -1;
out:
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
*last_blk = i;
out:
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
goto bp_err;
}
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
if (head_blk == log_bbnum)
*return_head_blk = 0;
else
return 0;
bp_err:
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
if (error)
xfs_warn(log->l_mp, "failed to find log head");
}
if (!found) {
xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
ASSERT(0);
return XFS_ERROR(EIO);
}
error = xlog_clear_stale_blocks(log, tail_lsn);
done:
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
if (error)
xfs_warn(log->l_mp, "failed to locate log tail");
first_cycle = xlog_get_cycle(offset);
if (first_cycle == 0) { /* completely zeroed log */
*blk_no = 0;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return -1;
}
last_cycle = xlog_get_cycle(offset);
if (last_cycle != 0) { /* log completely written to */
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 0;
} else if (first_cycle != 1) {
/*
*blk_no = last_blk;
bp_err:
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
if (error)
return error;
return -1;
hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
if (h_size % XLOG_HEADER_CYCLE_SIZE)
hblks++;
- libxfs_buf_relse(hbp);
+ xfs_buf_relse(hbp);
hbp = xlog_get_bp(log, hblks);
} else {
hblks = 1;
return ENOMEM;
dbp = xlog_get_bp(log, BTOBB(h_size));
if (!dbp) {
- libxfs_buf_relse(hbp);
+ xfs_buf_relse(hbp);
return ENOMEM;
}
}
bread_err2:
- libxfs_buf_relse(dbp);
+ xfs_buf_relse(dbp);
bread_err1:
- libxfs_buf_relse(hbp);
+ xfs_buf_relse(hbp);
return error;
}
count = sfp->count;
sfep = xfs_dir2_sf_firstentry(sfp);
for (i = 0; i < count; i++) {
- ino = libxfs_dir2_sf_get_ino(log->l_mp, sfp, sfep);
+ ino = xfs_dir2_sf_get_ino(log->l_mp, sfp, sfep);
memmove(namebuf, (sfep->name), sfep->namelen);
namebuf[sfep->namelen] = '\0';
printf(_("%s ino 0x%llx namelen %d\n"),
namebuf, (unsigned long long)ino, sfep->namelen);
- sfep = libxfs_dir2_sf_nextentry(log->l_mp, sfp, sfep);
+ sfep = xfs_dir2_sf_nextentry(log->l_mp, sfp, sfep);
}
}
error = xlog_find_cycle_start(log, bp, first_blk,
last_blk, last_half_cycle);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
* Conjure up a mount structure
*/
sb = &mp->m_sb;
- libxfs_sb_from_disk(sb, (xfs_dsb_t *)buf);
+ xfs_sb_from_disk(sb, (xfs_dsb_t *)buf);
mp->m_blkbb_log = sb->sb_blocklog - BBSHIFT;
x.logBBsize = XFS_FSB_TO_BB(mp, sb->sb_logblocks);
if (fread(block_buffer, mb_count << mbp->mb_blocklog, 1, src_f) != 1)
fatal("error reading from metadump file\n");
- libxfs_sb_from_disk(&sb, (xfs_dsb_t *)block_buffer);
+ xfs_sb_from_disk(&sb, (xfs_dsb_t *)block_buffer);
if (sb.sb_magicnum != XFS_SB_MAGIC)
fatal("bad magic number for primary superblock\n");
memset(block_buffer, 0, sb.sb_sectsize);
sb.sb_inprogress = 0;
- libxfs_sb_to_disk((xfs_dsb_t *)block_buffer, &sb);
+ xfs_sb_to_disk((xfs_dsb_t *)block_buffer, &sb);
if (xfs_sb_version_hascrc(&sb)) {
xfs_update_cksum(block_buffer, sb.sb_sectsize,
offsetof(struct xfs_sb, sb_crc));
uint r;
for (i = 0, r = MKFS_BLOCKRES(blocks); r >= blocks; r--) {
- i = -libxfs_trans_alloc_rollable(mp, r, &tp);
+ i = -xfs_trans_alloc_rollable(mp, r, &tp);
if (i == 0)
return tp;
}
int error;
xfs_trans_t *tp;
- error = -libxfs_alloc_file_space(ip, 0, llen, 1, 0);
+ error = -xfs_alloc_file_space(ip, 0, llen, 1, 0);
if (error) {
fail(_("error reserving space for a file"), error);
/*
* update the inode timestamp, mode, and prealloc flag bits
*/
- error = -libxfs_trans_alloc_rollable(mp, 0, &tp);
+ error = -xfs_trans_alloc_rollable(mp, 0, &tp);
if (error)
fail(_("allocating transaction for a file"), error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
VFS_I(ip)->i_mode &= ~S_ISUID;
if (VFS_I(ip)->i_mode & S_IXGRP)
VFS_I(ip)->i_mode &= ~S_ISGID;
- libxfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+ xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ error = -xfs_trans_commit(tp);
if (error)
fail(_("committing space for a file failed"), error);
}
flags = 0;
mp = ip->i_mount;
if (symlink && len <= XFS_IFORK_DSIZE(ip)) {
- libxfs_init_local_fork(ip, XFS_DATA_FORK, buf, len);
+ xfs_init_local_fork(ip, XFS_DATA_FORK, buf, len);
ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
flags = XFS_ILOG_DDATA;
} else if (len > 0) {
nb = XFS_B_TO_FSB(mp, len);
nmap = 1;
- error = -libxfs_bmapi_write(tp, ip, 0, nb, 0, nb, &map, &nmap);
+ error = -xfs_bmapi_write(tp, ip, 0, nb, 0, nb, &map, &nmap);
if (error) {
fail(_("error allocating space for a file"), error);
}
exit(1);
}
d = XFS_FSB_TO_DADDR(mp, map.br_startblock);
- error = -libxfs_trans_get_buf(logit ? tp : NULL, mp->m_dev, d,
+ error = -xfs_trans_get_buf(logit ? tp : NULL, mp->m_dev, d,
nb << mp->m_blkbb_log, 0, &bp);
if (error) {
fprintf(stderr,
if (len < bp->b_bcount)
memset((char *)bp->b_addr + len, 0, bp->b_bcount - len);
if (logit)
- libxfs_trans_log_buf(tp, bp, 0, bp->b_bcount - 1);
+ xfs_trans_log_buf(tp, bp, 0, bp->b_bcount - 1);
else {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
}
ip->i_d.di_size = len;
rsv = XFS_DIRENTER_SPACE_RES(mp, name->len);
- error = -libxfs_dir_createname(tp, pip, name, inum, rsv);
+ error = -xfs_dir_createname(tp, pip, name, inum, rsv);
if (error)
fail(_("directory createname error"), error);
}
{
int error;
- error = -libxfs_dir_init(tp, dp, pdp);
+ error = -xfs_dir_init(tp, dp, pdp);
if (error)
fail(_("directory create error"), error);
}
case IF_REGULAR:
buf = newregfile(pp, &len);
tp = getres(mp, XFS_B_TO_FSB(mp, len));
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFREG, 1, 0,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFREG, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
flags |= newfile(tp, ip, 0, 0, buf, len);
if (buf)
free(buf);
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_REG_FILE;
newdirent(mp, tp, pip, &xname, ip->i_ino);
break;
}
tp = getres(mp, XFS_B_TO_FSB(mp, llen));
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFREG, 1, 0,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFREG, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode pre-allocation failed"), error);
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_REG_FILE;
newdirent(mp, tp, pip, &xname, ip->i_ino);
- libxfs_trans_log_inode(tp, ip, flags);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ip, flags);
+ error = -xfs_trans_commit(tp);
if (error)
fail(_("Space preallocation failed."), error);
rsvfile(mp, ip, llen);
tp = getres(mp, 0);
majdev = getnum(getstr(pp), 0, 0, false);
mindev = getnum(getstr(pp), 0, 0, false);
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFBLK, 1,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFBLK, 1,
IRIX_MKDEV(majdev, mindev), &creds, fsxp, &ip);
if (error) {
fail(_("Inode allocation failed"), error);
}
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_BLKDEV;
newdirent(mp, tp, pip, &xname, ip->i_ino);
flags |= XFS_ILOG_DEV;
tp = getres(mp, 0);
majdev = getnum(getstr(pp), 0, 0, false);
mindev = getnum(getstr(pp), 0, 0, false);
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFCHR, 1,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFCHR, 1,
IRIX_MKDEV(majdev, mindev), &creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_CHRDEV;
newdirent(mp, tp, pip, &xname, ip->i_ino);
flags |= XFS_ILOG_DEV;
case IF_FIFO:
tp = getres(mp, 0);
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFIFO, 1, 0,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFIFO, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_FIFO;
newdirent(mp, tp, pip, &xname, ip->i_ino);
break;
buf = getstr(pp);
len = (int)strlen(buf);
tp = getres(mp, XFS_B_TO_FSB(mp, len));
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFLNK, 1, 0,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFLNK, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
flags |= newfile(tp, ip, 1, 1, buf, len);
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_SYMLINK;
newdirent(mp, tp, pip, &xname, ip->i_ino);
break;
case IF_DIRECTORY:
tp = getres(mp, 0);
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFDIR, 1, 0,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFDIR, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
if (!pip) {
pip = ip;
mp->m_sb.sb_rootino = ip->i_ino;
- libxfs_log_sb(tp);
+ xfs_log_sb(tp);
isroot = 1;
} else {
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_DIR;
newdirent(mp, tp, pip, &xname, ip->i_ino);
inc_nlink(VFS_I(pip));
- libxfs_trans_log_inode(tp, pip, XFS_ILOG_CORE);
+ xfs_trans_log_inode(tp, pip, XFS_ILOG_CORE);
}
newdirectory(mp, tp, ip, pip);
- libxfs_trans_log_inode(tp, ip, flags);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ip, flags);
+ error = -xfs_trans_commit(tp);
if (error)
fail(_("Directory inode allocation failed."), error);
/*
ASSERT(0);
fail(_("Unknown format"), EINVAL);
}
- libxfs_trans_log_inode(tp, ip, flags);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ip, flags);
+ error = -xfs_trans_commit(tp);
if (error) {
fail(_("Error encountered creating file from prototype file"),
error);
/*
* First, allocate the inodes.
*/
- i = -libxfs_trans_alloc_rollable(mp, MKFS_BLOCKRES_INODE, &tp);
+ i = -xfs_trans_alloc_rollable(mp, MKFS_BLOCKRES_INODE, &tp);
if (i)
res_failed(i);
memset(&creds, 0, sizeof(creds));
memset(&fsxattrs, 0, sizeof(fsxattrs));
- error = -libxfs_inode_alloc(&tp, NULL, S_IFREG, 1, 0,
+ error = -xfs_inode_alloc(&tp, NULL, S_IFREG, 1, 0,
&creds, &fsxattrs, &rbmip);
if (error) {
fail(_("Realtime bitmap inode allocation failed"), error);
rbmip->i_d.di_size = mp->m_sb.sb_rbmblocks * mp->m_sb.sb_blocksize;
rbmip->i_d.di_flags = XFS_DIFLAG_NEWRTBM;
*(uint64_t *)&VFS_I(rbmip)->i_atime = 0;
- libxfs_trans_log_inode(tp, rbmip, XFS_ILOG_CORE);
- libxfs_log_sb(tp);
+ xfs_trans_log_inode(tp, rbmip, XFS_ILOG_CORE);
+ xfs_log_sb(tp);
mp->m_rbmip = rbmip;
- error = -libxfs_inode_alloc(&tp, NULL, S_IFREG, 1, 0,
+ error = -xfs_inode_alloc(&tp, NULL, S_IFREG, 1, 0,
&creds, &fsxattrs, &rsumip);
if (error) {
fail(_("Realtime summary inode allocation failed"), error);
}
mp->m_sb.sb_rsumino = rsumip->i_ino;
rsumip->i_d.di_size = mp->m_rsumsize;
- libxfs_trans_log_inode(tp, rsumip, XFS_ILOG_CORE);
- libxfs_log_sb(tp);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, rsumip, XFS_ILOG_CORE);
+ xfs_log_sb(tp);
+ error = -xfs_trans_commit(tp);
if (error)
fail(_("Completion of the realtime summary inode failed"),
error);
*/
blocks = mp->m_sb.sb_rbmblocks +
XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 1;
- i = -libxfs_trans_alloc_rollable(mp, blocks, &tp);
+ i = -xfs_trans_alloc_rollable(mp, blocks, &tp);
if (i)
res_failed(i);
- libxfs_trans_ijoin(tp, rbmip, 0);
+ xfs_trans_ijoin(tp, rbmip, 0);
bno = 0;
while (bno < mp->m_sb.sb_rbmblocks) {
nmap = XFS_BMAP_MAX_NMAP;
- error = -libxfs_bmapi_write(tp, rbmip, bno,
+ error = -xfs_bmapi_write(tp, rbmip, bno,
(xfs_extlen_t)(mp->m_sb.sb_rbmblocks - bno),
0, mp->m_sb.sb_rbmblocks, map, &nmap);
if (error) {
}
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
fail(_("Block allocation of the realtime bitmap inode failed"),
error);
*/
nsumblocks = mp->m_rsumsize >> mp->m_sb.sb_blocklog;
blocks = nsumblocks + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 1;
- i = -libxfs_trans_alloc_rollable(mp, blocks, &tp);
+ i = -xfs_trans_alloc_rollable(mp, blocks, &tp);
if (i)
res_failed(i);
- libxfs_trans_ijoin(tp, rsumip, 0);
+ xfs_trans_ijoin(tp, rsumip, 0);
bno = 0;
while (bno < nsumblocks) {
nmap = XFS_BMAP_MAX_NMAP;
- error = -libxfs_bmapi_write(tp, rsumip, bno,
+ error = -xfs_bmapi_write(tp, rsumip, bno,
(xfs_extlen_t)(nsumblocks - bno),
0, nsumblocks, map, &nmap);
if (error) {
bno += ep->br_blockcount;
}
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
fail(_("Block allocation of the realtime summary inode failed"),
error);
* Do one transaction per bitmap block.
*/
for (bno = 0; bno < mp->m_sb.sb_rextents; bno = ebno) {
- i = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
+ i = -xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
0, 0, 0, &tp);
if (i)
res_failed(i);
- libxfs_trans_ijoin(tp, rbmip, 0);
+ xfs_trans_ijoin(tp, rbmip, 0);
ebno = XFS_RTMIN(mp->m_sb.sb_rextents,
bno + NBBY * mp->m_sb.sb_blocksize);
- error = -libxfs_rtfree_extent(tp, bno, (xfs_extlen_t)(ebno-bno));
+ error = -xfs_rtfree_extent(tp, bno, (xfs_extlen_t)(ebno-bno));
if (error) {
fail(_("Error initializing the realtime space"),
error);
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
fail(_("Initialization of the realtime space failed"),
error);
strerror(errno));
goto done;
}
- libxfs_sb_from_disk(&sb, buf);
+ xfs_sb_from_disk(&sb, buf);
/*
* perform same basic superblock validation to make sure we
} else
cfg->sectorsize = cli->sectorsize;
- cfg->sectorlog = libxfs_highbit32(cfg->sectorsize);
+ cfg->sectorlog = xfs_highbit32(cfg->sectorsize);
/* validate specified/probed sector size */
if (cfg->sectorsize < XFS_MIN_SECTORSIZE ||
cfg->blocksize = dft->blocksize;
else
cfg->blocksize = cli->blocksize;
- cfg->blocklog = libxfs_highbit32(cfg->blocksize);
+ cfg->blocklog = xfs_highbit32(cfg->blocksize);
/* validate block sizes are in range */
if (cfg->blocksize < XFS_MIN_BLOCKSIZE ||
cfg->lsectorsize = cfg->sectorsize;
else
cfg->lsectorsize = dft->sectorsize;
- cfg->lsectorlog = libxfs_highbit32(cfg->lsectorsize);
+ cfg->lsectorlog = xfs_highbit32(cfg->lsectorsize);
if (cfg->lsectorsize < XFS_MIN_SECTORSIZE ||
cfg->lsectorsize > XFS_MAX_SECTORSIZE ||
cfg->dirblocksize);
usage();
}
- cfg->dirblocklog = libxfs_highbit32(cfg->dirblocksize);
+ cfg->dirblocklog = xfs_highbit32(cfg->dirblocksize);
return;
}
{
if (cli->inopblock)
- cfg->inodelog = cfg->blocklog - libxfs_highbit32(cli->inopblock);
+ cfg->inodelog = cfg->blocklog - xfs_highbit32(cli->inopblock);
else if (cli->inodesize)
- cfg->inodelog = libxfs_highbit32(cli->inodesize);
+ cfg->inodelog = xfs_highbit32(cli->inodesize);
else if (cfg->sb_feat.crcs_enabled)
cfg->inodelog = XFS_DINODE_DFL_CRC_LOG;
else
if (cli->fsx.fsx_xflags & FS_XFLAG_EXTSZINHERIT)
flags |= XFS_DIFLAG_EXTSZINHERIT;
- fa = libxfs_inode_validate_extsize(mp, cli->fsx.fsx_extsize, S_IFDIR,
+ fa = xfs_inode_validate_extsize(mp, cli->fsx.fsx_extsize, S_IFDIR,
flags);
if (fa) {
fprintf(stderr,
if (cli->fsx.fsx_xflags & FS_XFLAG_EXTSZINHERIT)
flags |= XFS_DIFLAG_EXTSIZE;
- fa = libxfs_inode_validate_extsize(mp, cli->fsx.fsx_extsize, S_IFREG,
+ fa = xfs_inode_validate_extsize(mp, cli->fsx.fsx_extsize, S_IFREG,
flags);
if (fa) {
if (cli->fsx.fsx_xflags & FS_XFLAG_COWEXTSIZE)
flags2 |= XFS_DIFLAG2_COWEXTSIZE;
- fa = libxfs_inode_validate_cowextsize(mp, cli->fsx.fsx_cowextsize,
+ fa = xfs_inode_validate_cowextsize(mp, cli->fsx.fsx_cowextsize,
S_IFDIR, 0, flags2);
if (fa) {
fprintf(stderr,
memset(&mount, 0, sizeof(mount));
mount.m_sb = *sbp;
libxfs_mount(&mount, &mp->m_sb, 0, 0, 0, 0);
- min_logblocks = libxfs_log_calc_minimum_size(&mount);
+ min_logblocks = xfs_log_calc_minimum_size(&mount);
libxfs_umount(&mount);
ASSERT(min_logblocks);
* an AG.
*/
cfg->logblocks = min(cfg->logblocks,
- libxfs_alloc_ag_max_usable(mp) - 1);
+ xfs_alloc_ag_max_usable(mp) - 1);
/* and now clamp the size to the maximum supported size */
cfg->logblocks = min(cfg->logblocks, XFS_MAX_LOG_BLOCKS);
validate_log_size(cfg->logblocks, cfg->blocklog, min_logblocks);
}
- if (cfg->logblocks > sbp->sb_agblocks - libxfs_prealloc_blocks(mp)) {
+ if (cfg->logblocks > sbp->sb_agblocks - xfs_prealloc_blocks(mp)) {
fprintf(stderr,
_("internal log size %lld too large, must fit in allocation group\n"),
(long long)cfg->logblocks);
cfg->logagno = (xfs_agnumber_t)(sbp->sb_agcount / 2);
cfg->logstart = XFS_AGB_TO_FSB(mp, cfg->logagno,
- libxfs_prealloc_blocks(mp));
+ xfs_prealloc_blocks(mp));
/*
* Align the logstart at stripe unit boundary.
struct xfs_mount *mp,
struct xfs_sb *sbp)
{
- /* Minimum needed for libxfs_prealloc_blocks() */
+ /* Minimum needed for xfs_prealloc_blocks() */
mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
}
sbp->sb_rbmblocks = cfg->rtbmblocks;
sbp->sb_logblocks = (xfs_extlen_t)cfg->logblocks;
sbp->sb_rextslog = (uint8_t)(cfg->rtextents ?
- libxfs_highbit32((unsigned int)cfg->rtextents) : 0);
+ xfs_highbit32((unsigned int)cfg->rtextents) : 0);
sbp->sb_inprogress = 1; /* mkfs is in progress */
sbp->sb_imax_pct = cfg->imaxpct;
sbp->sb_icount = 0;
sbp->sb_ifree = 0;
sbp->sb_fdblocks = cfg->dblocks -
- cfg->agcount * libxfs_prealloc_blocks(mp) -
+ cfg->agcount * xfs_prealloc_blocks(mp) -
(cfg->loginternal ? cfg->logblocks : 0);
sbp->sb_frextents = 0; /* will do a free later */
sbp->sb_uquotino = sbp->sb_gquotino = sbp->sb_pquotino = 0;
struct xfs_buf *bp;
int error;
- error = -libxfs_buf_get_uncached(btp, bblen, 0, &bp);
+ error = -xfs_buf_get_uncached(btp, bblen, 0, &bp);
if (error) {
fprintf(stderr, _("Could not get memory for buffer, err=%d\n"),
error);
whack_blks);
memset(buf->b_addr, 0, WHACK_SIZE);
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
/*
* Now zero out the beginning of the device, to obliterate any old
buf = alloc_write_buf(mp->m_ddev_targp, 0, whack_blks);
memset(buf->b_addr, 0, WHACK_SIZE);
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
/* OK, now write the superblock... */
buf = alloc_write_buf(mp->m_ddev_targp, XFS_SB_DADDR,
XFS_FSS_TO_BB(mp, 1));
buf->b_ops = &xfs_sb_buf_ops;
memset(buf->b_addr, 0, cfg->sectorsize);
- libxfs_sb_to_disk(buf->b_addr, sbp);
+ xfs_sb_to_disk(buf->b_addr, sbp);
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
/* ...and zero the log.... */
lsunit = sbp->sb_logsunit;
BTOBB(cfg->blocksize));
memset(buf->b_addr, 0, cfg->blocksize);
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
}
}
.agno = agno,
.agsize = cfg->agsize,
};
- struct xfs_perag *pag = libxfs_perag_get(mp, agno);
+ struct xfs_perag *pag = xfs_perag_get(mp, agno);
int error;
if (agno == cfg->agcount - 1)
id.agsize = cfg->dblocks - (xfs_rfsblock_t)(agno * cfg->agsize);
INIT_LIST_HEAD(&id.buffer_list);
- error = -libxfs_ag_init_headers(mp, &id);
+ error = -xfs_ag_init_headers(mp, &id);
if (error) {
fprintf(stderr, _("AG header init failed, error %d\n"), error);
exit(1);
list_splice_tail_init(&id.buffer_list, buffer_list);
- if (libxfs_alloc_min_freelist(mp, pag) > *worst_freelist)
- *worst_freelist = libxfs_alloc_min_freelist(mp, pag);
- libxfs_perag_put(pag);
+ if (xfs_alloc_min_freelist(mp, pag) > *worst_freelist)
+ *worst_freelist = xfs_alloc_min_freelist(mp, pag);
+ xfs_perag_put(pag);
}
static void
struct xfs_trans *tp;
int c;
- c = -libxfs_trans_alloc_rollable(mp, worst_freelist, &tp);
+ c = -xfs_trans_alloc_rollable(mp, worst_freelist, &tp);
if (c)
res_failed(c);
args.mp = mp;
args.agno = agno;
args.alignment = 1;
- args.pag = libxfs_perag_get(mp, agno);
+ args.pag = xfs_perag_get(mp, agno);
- libxfs_alloc_fix_freelist(&args, 0);
- libxfs_perag_put(args.pag);
- c = -libxfs_trans_commit(tp);
+ xfs_alloc_fix_freelist(&args, 0);
+ xfs_perag_put(args.pag);
+ c = -xfs_trans_commit(tp);
if (c) {
errno = c;
perror(_("initializing AG free space list"));
int error;
/* rewrite the last superblock */
- error = -libxfs_buf_read(mp->m_dev,
+ error = -xfs_buf_read(mp->m_dev,
XFS_AGB_TO_DADDR(mp, mp->m_sb.sb_agcount - 1,
XFS_SB_DADDR),
XFS_FSS_TO_BB(mp, 1), 0, &buf, &xfs_sb_buf_ops);
dsb = buf->b_addr;
dsb->sb_rootino = cpu_to_be64(mp->m_sb.sb_rootino);
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
/* and one in the middle for luck if there's enough AGs for that */
if (mp->m_sb.sb_agcount <= 2)
return;
- error = -libxfs_buf_read(mp->m_dev,
+ error = -xfs_buf_read(mp->m_dev,
XFS_AGB_TO_DADDR(mp, (mp->m_sb.sb_agcount - 1) / 2,
XFS_SB_DADDR),
XFS_FSS_TO_BB(mp, 1), 0, &buf, &xfs_sb_buf_ops);
dsb = buf->b_addr;
dsb->sb_rootino = cpu_to_be64(mp->m_sb.sb_rootino);
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
}
static void
* Fail the format immediately if those assumptions ever break, because
* repair will toss the root directory.
*/
- ino = libxfs_ialloc_calc_rootino(mp, mp->m_sb.sb_unit);
+ ino = xfs_ialloc_calc_rootino(mp, mp->m_sb.sb_unit);
if (mp->m_sb.sb_rootino != ino) {
fprintf(stderr,
_("%s: root inode (%llu) not allocated in expected location (%llu)\n"),
if (!quiet || dry_run) {
struct xfs_fsop_geom geo;
- libxfs_fs_geometry(sbp, &geo, XFS_FS_GEOM_MAX_STRUCT_VER);
+ xfs_fs_geometry(sbp, &geo, XFS_FS_GEOM_MAX_STRUCT_VER);
xfs_report_geom(&geo, dfile, logfile, rtfile);
if (dry_run)
exit(0);
if (agno % 16)
continue;
- error = -libxfs_buf_delwri_submit(&buffer_list);
+ error = -xfs_buf_delwri_submit(&buffer_list);
if (error) {
fprintf(stderr,
_("%s: writing AG headers failed, err=%d\n"),
}
}
- error = -libxfs_buf_delwri_submit(&buffer_list);
+ error = -xfs_buf_delwri_submit(&buffer_list);
if (error) {
fprintf(stderr, _("%s: writing AG headers failed, err=%d\n"),
progname, error);
dsb = buf->b_addr;
dsb->sb_inprogress = 0;
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
/* Exit w/ failure if anything failed to get written to our new fs. */
error = -libxfs_umount(mp);
* check first/last AGF fields. if need be, lose the free
* space in the AGFL, we'll reclaim it later.
*/
- if (be32_to_cpu(agf->agf_flfirst) >= libxfs_agfl_size(mp)) {
+ if (be32_to_cpu(agf->agf_flfirst) >= xfs_agfl_size(mp)) {
do_warn(_("flfirst %d in agf %d too large (max = %u)\n"),
be32_to_cpu(agf->agf_flfirst),
- i, libxfs_agfl_size(mp) - 1);
+ i, xfs_agfl_size(mp) - 1);
if (!no_modify)
agf->agf_flfirst = cpu_to_be32(0);
}
- if (be32_to_cpu(agf->agf_fllast) >= libxfs_agfl_size(mp)) {
+ if (be32_to_cpu(agf->agf_fllast) >= xfs_agfl_size(mp)) {
do_warn(_("fllast %d in agf %d too large (max = %u)\n"),
be32_to_cpu(agf->agf_fllast),
- i, libxfs_agfl_size(mp) - 1);
+ i, xfs_agfl_size(mp) - 1);
if (!no_modify)
agf->agf_fllast = cpu_to_be32(0);
}
* secondaries.
*
* Also, the in-core inode flags now have different meaning to the
- * on-disk flags, and so libxfs_sb_to_disk cannot directly write the
+ * on-disk flags, and so xfs_sb_to_disk cannot directly write the
* sb_gquotino/sb_pquotino fields without specific sb_qflags being set.
* Hence we need to zero those fields directly in the sb buffer here.
*/
}
/* namecheck checks for null chars in attr names. */
- if (!libxfs_attr_namecheck(currententry->nameval,
+ if (!xfs_attr_namecheck(currententry->nameval,
currententry->namelen)) {
do_warn(
_("entry contains illegal character in shortform attribute name\n"));
clearit = 1;
break;
}
- error = -libxfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
+ error = -xfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
XFS_FSB_TO_BB(mp, 1), LIBXFS_READBUF_SALVAGE,
&bp, &xfs_attr3_rmt_buf_ops);
if (error) {
if (bp->b_error == -EFSBADCRC || bp->b_error == -EFSCORRUPTED) {
do_warn(
_("Corrupt remote block for attributes of inode %" PRIu64 "\n"), ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
clearit = 1;
break;
}
amountdone += length;
value += length;
i++;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
return (clearit);
}
local = xfs_attr3_leaf_name_local(leaf, i);
if (local->namelen == 0 ||
- !libxfs_attr_namecheck(local->nameval,
- local->namelen)) {
+ !xfs_attr_namecheck(local->nameval, local->namelen)) {
do_warn(
_("attribute entry %d in attr block %u, inode %" PRIu64 " has bad name (namelen = %d)\n"),
i, da_bno, ino, local->namelen);
* ordering anyway in case both the name value and the
* hashvalue were wrong but matched. Unlikely, however.
*/
- if (be32_to_cpu(entry->hashval) != libxfs_da_hashname(
+ if (be32_to_cpu(entry->hashval) != xfs_da_hashname(
&local->nameval[0], local->namelen) ||
be32_to_cpu(entry->hashval) < last_hashval) {
do_warn(
remotep = xfs_attr3_leaf_name_remote(leaf, i);
if (remotep->namelen == 0 ||
- !libxfs_attr_namecheck(remotep->name,
- remotep->namelen) ||
+ !xfs_attr_namecheck(remotep->name, remotep->namelen) ||
be32_to_cpu(entry->hashval) !=
- libxfs_da_hashname((unsigned char *)&remotep->name[0],
+ xfs_da_hashname((unsigned char *)&remotep->name[0],
remotep->namelen) ||
be32_to_cpu(entry->hashval) < last_hashval ||
be32_to_cpu(remotep->valueblk) == 0) {
goto error_out;
}
- error = -libxfs_buf_read(mp->m_dev,
+ error = -xfs_buf_read(mp->m_dev,
XFS_FSB_TO_DADDR(mp, dev_bno),
XFS_FSB_TO_BB(mp, 1), LIBXFS_READBUF_SALVAGE,
&bp, &xfs_attr3_leaf_buf_ops);
do_warn(
_("bad attribute leaf magic %#x for inode %" PRIu64 "\n"),
leafhdr.magic, ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
if (process_leaf_attr_block(mp, leaf, da_bno, ino,
da_cursor->blkmap, current_hashval,
&greatest_hashval, &repair)) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
do_warn(
_("bad sibling back pointer for block %u in attribute fork for inode %" PRIu64 "\n"),
da_bno, ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
if (da_bno != 0) {
if (verify_da_path(mp, da_cursor, 0, XFS_ATTR_FORK)) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
}
if (repair && !no_modify) {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
} while (da_bno != 0);
if (verify_final_da_path(mp, da_cursor, 0, XFS_ATTR_FORK)) {
if (badness) {
*repair = 0;
/* the block is bad. lose the attribute fork. */
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
if (*repair && !no_modify)
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 0;
}
int repairlinks = 0;
int error;
- libxfs_da3_node_hdr_from_disk(mp, &da3_hdr, bp->b_addr);
+ xfs_da3_node_hdr_from_disk(mp, &da3_hdr, bp->b_addr);
/*
* check sibling pointers in leaf block or root block 0 before
* we have to release the btree block
*repair = 1;
libxfs_buf_mark_dirty(bp);
}
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
error = process_node_attr(mp, ino, dip, blkmap); /* + repair */
if (error)
*repair = 0;
return 1;
}
- error = -libxfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
+ error = -xfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
XFS_FSB_TO_BB(mp, 1), LIBXFS_READBUF_SALVAGE, &bp,
&xfs_da3_node_buf_ops);
if (error) {
/* is this block sane? */
if (__check_attr_header(mp, bp, ino)) {
*repair = 0;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
do_warn(
_("bad attribute leaf magic # %#x for dir ino %" PRIu64 "\n"),
be16_to_cpu(info->magic), ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
*repair = 0;
return 1;
}
map[i].bm_bn = XFS_FSB_TO_DADDR(mp, bmp[i].startblock);
map[i].bm_len = XFS_FSB_TO_BB(mp, bmp[i].blockcount);
}
- libxfs_buf_read_map(mp->m_dev, map, nex, LIBXFS_READBUF_SALVAGE,
+ xfs_buf_read_map(mp->m_dev, map, nex, LIBXFS_READBUF_SALVAGE,
&bp, ops);
if (map != map_array)
free(map);
}
node = bp->b_addr;
- libxfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
+ xfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
if (whichfork == XFS_DATA_FORK &&
(nodehdr.magic == XFS_DIR2_LEAFN_MAGIC ||
da_cursor->ino, bno);
}
*rbno = 0;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
_("bad %s magic number 0x%x in inode %" PRIu64 " bno = %u\n"),
FORKNAME(whichfork), nodehdr.magic,
da_cursor->ino, bno);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
/* corrupt node; rebuild the dir. */
if (bp->b_error == -EFSBADCRC || bp->b_error == -EFSCORRUPTED) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
do_warn(
_("corrupt %s tree block %u for inode %" PRIu64 "\n"),
FORKNAME(whichfork), bno, da_cursor->ino);
_("bad %s record count in inode %" PRIu64 ", count = %d, max = %d\n"),
FORKNAME(whichfork), da_cursor->ino,
nodehdr.count, geo->node_ents);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
do_warn(
_("bad header depth for directory inode %" PRIu64 "\n"),
da_cursor->ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
i = -1;
goto error_out;
}
do_warn(
_("bad %s btree for inode %" PRIu64 "\n"),
FORKNAME(whichfork), da_cursor->ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
}
error_out:
while (i > 1 && i <= da_cursor->active) {
- libxfs_buf_relse(da_cursor->level[i].bp);
+ xfs_buf_relse(da_cursor->level[i].bp);
i++;
}
}
ASSERT(error != 0);
- libxfs_buf_relse(cursor->level[level].bp);
+ xfs_buf_relse(cursor->level[level].bp);
cursor->level[level].bp = NULL;
}
*/
entry = cursor->level[this_level].index;
node = cursor->level[this_level].bp->b_addr;
- libxfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
+ xfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
/*
* check internal block consistency on this level -- ensure
if (cursor->level[this_level].dirty && !no_modify) {
libxfs_buf_mark_dirty(cursor->level[this_level].bp);
- libxfs_buf_relse(cursor->level[this_level].bp);
+ xfs_buf_relse(cursor->level[this_level].bp);
}
else
- libxfs_buf_relse(cursor->level[this_level].bp);
+ xfs_buf_relse(cursor->level[this_level].bp);
cursor->level[this_level].bp = NULL;
*/
entry = cursor->level[this_level].index;
node = cursor->level[this_level].bp->b_addr;
- libxfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
+ xfs_da3_node_hdr_from_disk(mp, &nodehdr, node);
/* No entries in this node? Tree is corrupt. */
if (nodehdr.count == 0)
}
newnode = bp->b_addr;
- libxfs_da3_node_hdr_from_disk(mp, &nodehdr, newnode);
+ xfs_da3_node_hdr_from_disk(mp, &nodehdr, newnode);
/*
* verify magic number and back pointer, sanity-check
#ifdef XR_DIR_TRACE
fprintf(stderr, "verify_da_path returns 1 (bad) #4\n");
#endif
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
if (cursor->level[this_level].dirty && !no_modify) {
libxfs_buf_mark_dirty(cursor->level[this_level].bp);
- libxfs_buf_relse(cursor->level[this_level].bp);
+ xfs_buf_relse(cursor->level[this_level].bp);
}
else
- libxfs_buf_relse(cursor->level[this_level].bp);
+ xfs_buf_relse(cursor->level[this_level].bp);
/* switch cursor to point at the new buffer we just read */
cursor->level[this_level].bp = bp;
* tree and we wouldn't be here and we stale the buffers out
* so no one else will overlap them.
*/
- error = -libxfs_buf_read(mp->m_dev, XFS_AGB_TO_DADDR(mp, agno, agbno),
+ error = -xfs_buf_read(mp->m_dev, XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), LIBXFS_READBUF_SALVAGE, &bp,
NULL);
if (error) {
if (cnt)
bp->b_ops = &xfs_inode_buf_ops;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return(cnt);
}
* inode chunk. returns number of new inodes if things are good
* and 0 if bad. start is the start of the discovered inode chunk.
* routine assumes that ino is a legal inode number
- * (verified by libxfs_verify_ino()). If the inode chunk turns out
+ * (verified by xfs_verify_ino()). If the inode chunk turns out
* to be good, this routine will put the inode chunk into
* the good inode chunk tree if required.
*
pftrace("about to read off %llu in AG %d",
XFS_AGB_TO_DADDR(mp, agno, agbno), agno);
- error = -libxfs_buf_read(mp->m_dev,
+ error = -xfs_buf_read(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp,
M_IGEO(mp)->blocks_per_cluster),
M_IGEO(mp)->blocks_per_cluster));
while (bp_index > 0) {
bp_index--;
- libxfs_buf_relse(bplist[bp_index]);
+ xfs_buf_relse(bplist[bp_index]);
}
free(bplist);
return(1);
*bogus = 1;
for (bp_index = 0; bp_index < cluster_count; bp_index++)
if (bplist[bp_index])
- libxfs_buf_relse(bplist[bp_index]);
+ xfs_buf_relse(bplist[bp_index]);
free(bplist);
return(0);
}
ASSERT(is_used != 3);
if (ino_dirty) {
dirty = 1;
- libxfs_dinode_calc_crc(mp, dino);
+ xfs_dinode_calc_crc(mp, dino);
}
/*
* phase 6.
*/
set_inode_ftype(ino_rec, irec_offset,
- libxfs_mode_to_ftype(be16_to_cpu(dino->di_mode)));
+ xfs_mode_to_ftype(be16_to_cpu(dino->di_mode)));
/*
* store on-disk nlink count for comparing in phase 7
if (dirty && !no_modify) {
libxfs_buf_mark_dirty(bplist[bp_index]);
- libxfs_buf_relse(bplist[bp_index]);
+ xfs_buf_relse(bplist[bp_index]);
}
else
- libxfs_buf_relse(bplist[bp_index]);
+ xfs_buf_relse(bplist[bp_index]);
}
free(bplist);
break;
cluster_agino, cluster_daddr, cluster_blks);
#endif
- error = -libxfs_buf_read(mp->m_dev, cluster_daddr, cluster_blks, 0,
+ error = -xfs_buf_read(mp->m_dev, cluster_daddr, cluster_blks, 0,
&bp, &xfs_inode_buf_ops);
if (error) {
do_warn(_("cannot read inode (%u/%u), disk block %" PRIu64 "\n"),
init_bm_cursor(&cursor, level + 1);
pp = XFS_BMDR_PTR_ADDR(dib, 1,
- libxfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork), 0));
+ xfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork), 0));
pkey = XFS_BMDR_KEY_ADDR(dib, 1);
last_key = NULLFILEOFF;
}
dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
- dqperchunk = libxfs_calc_dquots_per_chunk(dqchunklen);
+ dqperchunk = xfs_calc_dquots_per_chunk(dqchunklen);
dqid = 0;
qbno = NULLFILEOFF;
fsbno = blkmap_get(blkmap, qbno);
dqid = (xfs_dqid_t)qbno * dqperchunk;
- error = -libxfs_buf_read(mp->m_dev,
+ error = -xfs_buf_read(mp->m_dev,
XFS_FSB_TO_DADDR(mp, fsbno), dqchunklen,
LIBXFS_READBUF_SALVAGE, &bp,
&xfs_dquot_buf_ops);
/* We only print the first problem we find */
if (xfs_sb_version_hascrc(&mp->m_sb)) {
- if (!libxfs_verify_cksum((char *)dqb,
+ if (!xfs_verify_cksum((char *)dqb,
sizeof(*dqb),
XFS_DQUOT_CRC_OFF)) {
do_warn(_("%s: bad CRC for id %u. "),
goto bad;
}
}
- if (libxfs_dquot_verify(mp, &dqb->dd_diskdq, dqid,
+ if (xfs_dquot_verify(mp, &dqb->dd_diskdq, dqid,
quota_type) != NULL) {
do_warn(_("%s: Corrupt quota for id %u. "),
quota_string, dqid);
do_warn(_("Would correct.\n"));
else {
do_warn(_("Corrected.\n"));
- libxfs_dqblk_repair(mp, dqb,
+ xfs_dqblk_repair(mp, dqb,
dqid, quota_type);
writebuf = 1;
}
if (writebuf && !no_modify) {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
return 0;
}
byte_cnt = XFS_FSB_TO_B(mp, blk_cnt);
- error = -libxfs_buf_read(mp->m_dev,
+ error = -xfs_buf_read(mp->m_dev,
XFS_FSB_TO_DADDR(mp, fsbno), BTOBB(byte_cnt),
LIBXFS_READBUF_SALVAGE, &bp,
&xfs_symlink_buf_ops);
do_warn(
_("Corrupt symlink remote block %" PRIu64 ", inode %" PRIu64 ".\n"),
fsbno, lino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
if (bp->b_error == -EFSBADCRC) {
src = bp->b_addr;
if (xfs_sb_version_hascrc(&mp->m_sb)) {
- if (!libxfs_symlink_hdr_ok(lino, offset,
+ if (!xfs_symlink_hdr_ok(lino, offset,
byte_cnt, bp)) {
do_warn(
_("bad symlink header ino %" PRIu64 ", file block %d, disk block %" PRIu64 "\n"),
lino, i, fsbno);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
src += sizeof(struct xfs_dsymlink_hdr);
if (badcrc && !no_modify) {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
return 0;
}
* rewritten, and the CRC is updated automagically.
*/
if (xfs_sb_version_hascrc(&mp->m_sb) &&
- !libxfs_verify_cksum((char *)dino, mp->m_sb.sb_inodesize,
+ !xfs_verify_cksum((char *)dino, mp->m_sb.sb_inodesize,
XFS_DINODE_CRC_OFF)) {
retval = 1;
if (!uncertain)
}
}
- if (!libxfs_dinode_good_version(&mp->m_sb, dino->di_version)) {
+ if (!xfs_dinode_good_version(&mp->m_sb, dino->di_version)) {
retval = 1;
if (!uncertain)
do_warn(_("bad version number 0x%x on inode %" PRIu64 "%c"),
* it just in case to ensure that format, etc. are
* set correctly
*/
- if (libxfs_dinode_verify(mp, lino, dino) != NULL) {
+ if (xfs_dinode_verify(mp, lino, dino) != NULL) {
do_warn(
_("free inode %" PRIu64 " contains errors, "), lino);
if (!no_modify) {
* only regular files with REALTIME or EXTSIZE flags set can have
* extsize set, or directories with EXTSZINHERIT.
*/
- if (libxfs_inode_validate_extsize(mp,
+ if (xfs_inode_validate_extsize(mp,
be32_to_cpu(dino->di_extsize),
be16_to_cpu(dino->di_mode),
be16_to_cpu(dino->di_flags)) != NULL) {
* set can have extsize set.
*/
if (dino->di_version >= 3 &&
- libxfs_inode_validate_cowextsize(mp,
+ xfs_inode_validate_cowextsize(mp,
be32_to_cpu(dino->di_cowextsize),
be16_to_cpu(dino->di_mode),
be16_to_cpu(dino->di_flags),
memmove(oldsfp, newsfp, oldsize);
newsfp->count = oldsfp->count;
newsfp->i8count = 0;
- ino = libxfs_dir2_sf_get_parent_ino(sfp);
- libxfs_dir2_sf_put_parent_ino(newsfp, ino);
+ ino = xfs_dir2_sf_get_parent_ino(sfp);
+ xfs_dir2_sf_put_parent_ino(newsfp, ino);
oldsfep = xfs_dir2_sf_firstentry(oldsfp);
newsfep = xfs_dir2_sf_firstentry(newsfp);
while ((int)((char *)oldsfep - (char *)oldsfp) < oldsize) {
xfs_dir2_sf_put_offset(newsfep,
xfs_dir2_sf_get_offset(oldsfep));
memmove(newsfep->name, oldsfep->name, newsfep->namelen);
- ino = libxfs_dir2_sf_get_ino(mp, oldsfp, oldsfep);
- libxfs_dir2_sf_put_ino(mp, newsfp, newsfep, ino);
- oldsfep = libxfs_dir2_sf_nextentry(mp, oldsfp, oldsfep);
- newsfep = libxfs_dir2_sf_nextentry(mp, newsfp, newsfep);
+ ino = xfs_dir2_sf_get_ino(mp, oldsfp, oldsfep);
+ xfs_dir2_sf_put_ino(mp, newsfp, newsfep, ino);
+ oldsfep = xfs_dir2_sf_nextentry(mp, oldsfp, oldsfep);
+ newsfep = xfs_dir2_sf_nextentry(mp, newsfp, newsfep);
}
*next_sfep = newsfep;
free(oldsfp);
for (i = 0; i < sfp->count; i++) {
xfs_dir2_sf_put_offset(sfep, offset);
- offset += libxfs_dir2_data_entsize(mp, sfep->namelen);
- sfep = libxfs_dir2_sf_nextentry(mp, sfp, sfep);
+ offset += xfs_dir2_data_entsize(mp, sfep->namelen);
+ sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep);
}
}
/*
* Initialize i8 based on size of parent inode number.
*/
- i8 = (libxfs_dir2_sf_get_parent_ino(sfp) > XFS_DIR2_MAX_SHORT_INUM);
+ i8 = (xfs_dir2_sf_get_parent_ino(sfp) > XFS_DIR2_MAX_SHORT_INUM);
/*
* check for bad entry count
*/
- if (num_entries * libxfs_dir2_sf_entsize(mp, sfp, 1) +
+ if (num_entries * xfs_dir2_sf_entsize(mp, sfp, 1) +
xfs_dir2_sf_hdr_size(0) > max_size || num_entries == 0)
num_entries = 0xFF;
sfep = next_sfep;
junkit = 0;
bad_sfnamelen = 0;
- lino = libxfs_dir2_sf_get_ino(mp, sfp, sfep);
+ lino = xfs_dir2_sf_get_ino(mp, sfp, sfep);
/*
* if entry points to self, junk it since only '.' or '..'
* should do that and shortform dirs don't contain either
if (lino == ino) {
junkit = 1;
junkreason = _("current");
- } else if (!libxfs_verify_dir_ino(mp, lino)) {
+ } else if (!xfs_verify_dir_ino(mp, lino)) {
junkit = 1;
junkreason = _("invalid");
} else if (lino == mp->m_sb.sb_rbmino) {
junkreason = _("is zero length");
bad_sfnamelen = 1;
} else if ((intptr_t) sfep - (intptr_t) sfp +
- libxfs_dir2_sf_entsize(mp, sfp, sfep->namelen)
+ xfs_dir2_sf_entsize(mp, sfp, sfep->namelen)
> ino_dir_size) {
junkreason = _("extends past end of dir");
bad_sfnamelen = 1;
* the length value is stored in a byte
* so it can't be too big, it can only wrap
*/
- if (!libxfs_dir2_namecheck(sfep->name, namelen)) {
+ if (!xfs_dir2_namecheck(sfep->name, namelen)) {
/*
* junk entry
*/
bad_offset = 1;
}
offset = xfs_dir2_sf_get_offset(sfep) +
- libxfs_dir2_data_entsize(mp, namelen);
+ xfs_dir2_data_entsize(mp, namelen);
/*
* junk the entry by copying up the rest of the
name[namelen] = '\0';
if (!no_modify) {
- tmp_elen = libxfs_dir2_sf_entsize(mp, sfp,
+ tmp_elen = xfs_dir2_sf_entsize(mp, sfp,
sfep->namelen);
be64_add_cpu(&dip->di_size, -tmp_elen);
ino_dir_size -= tmp_elen;
next_sfep = (tmp_sfep == NULL)
? (xfs_dir2_sf_entry_t *) ((intptr_t) sfep
+ ((!bad_sfnamelen)
- ? libxfs_dir2_sf_entsize(mp, sfp, sfep->namelen)
- : libxfs_dir2_sf_entsize(mp, sfp, namelen)))
+ ? xfs_dir2_sf_entsize(mp, sfp, sfep->namelen)
+ : xfs_dir2_sf_entsize(mp, sfp, namelen)))
: tmp_sfep;
}
/*
* check parent (..) entry
*/
- *parent = libxfs_dir2_sf_get_parent_ino(sfp);
+ *parent = xfs_dir2_sf_get_parent_ino(sfp);
/*
* if parent entry is bogus, null it out. we'll fix it later .
* If the validation fails for the root inode we fix it in
* the next else case.
*/
- if (!libxfs_verify_dir_ino(mp, *parent) && ino != mp->m_sb.sb_rootino) {
+ if (!xfs_verify_dir_ino(mp, *parent) && ino != mp->m_sb.sb_rootino) {
do_warn(
_("bogus .. inode number (%" PRIu64 ") in directory inode %" PRIu64 ", "),
*parent, ino);
if (!no_modify) {
do_warn(_("clearing inode number\n"));
- libxfs_dir2_sf_put_parent_ino(sfp, zero);
+ xfs_dir2_sf_put_parent_ino(sfp, zero);
*dino_dirty = 1;
*repair = 1;
} else {
_("corrected root directory %" PRIu64 " .. entry, was %" PRIu64 ", now %" PRIu64 "\n"),
ino, *parent, ino);
*parent = ino;
- libxfs_dir2_sf_put_parent_ino(sfp, ino);
+ xfs_dir2_sf_put_parent_ino(sfp, ino);
*dino_dirty = 1;
*repair = 1;
} else {
if (!no_modify) {
do_warn(_("clearing inode number\n"));
- libxfs_dir2_sf_put_parent_ino(sfp, zero);
+ xfs_dir2_sf_put_parent_ino(sfp, zero);
*dino_dirty = 1;
*repair = 1;
} else {
xfs_ino_t ent_ino;
d = bp->b_addr;
- bf = libxfs_dir2_data_bestfree_p(mp, d);
+ bf = xfs_dir2_data_bestfree_p(mp, d);
ptr = (char *)d + mp->m_dir_geo->data_entry_offset;
badbest = lastfree = freeseen = 0;
if (be16_to_cpu(bf[0].length) == 0) {
continue;
}
dep = (xfs_dir2_data_entry_t *)ptr;
- if (ptr + libxfs_dir2_data_entsize(mp, dep->namelen) > endptr)
+ if (ptr + xfs_dir2_data_entsize(mp, dep->namelen) > endptr)
break;
- if (be16_to_cpu(*libxfs_dir2_data_entry_tag_p(mp, dep)) !=
+ if (be16_to_cpu(*xfs_dir2_data_entry_tag_p(mp, dep)) !=
(char *)dep - (char *)d)
break;
- ptr += libxfs_dir2_data_entsize(mp, dep->namelen);
+ ptr += xfs_dir2_data_entsize(mp, dep->namelen);
lastfree = 0;
}
/*
* (or did it ourselves) during phase 3.
*/
clearino = 0;
- } else if (!libxfs_verify_dir_ino(mp, ent_ino)) {
+ } else if (!xfs_verify_dir_ino(mp, ent_ino)) {
/*
* Bad inode number. Clear the inode number and the
* entry will get removed later. We don't trash the
* during phase 4.
*/
junkit = dep->name[0] == '/';
- nm_illegal = !libxfs_dir2_namecheck(dep->name, dep->namelen);
+ nm_illegal = !xfs_dir2_namecheck(dep->name, dep->namelen);
if (ino_discovery && nm_illegal) {
do_warn(
_("entry at block %u offset %" PRIdPTR " in directory inode %" PRIu64 " has illegal name \"%*.*s\": "),
*/
if (!junkit &&
*parent != NULLFSINO &&
- !libxfs_verify_ino(mp, *parent)) {
+ !xfs_verify_ino(mp, *parent)) {
do_warn(
_("bad .. entry in directory inode %" PRIu64 ", was %" PRIu64 ": "),
ino, *parent);
/*
* Advance to the next entry.
*/
- ptr += libxfs_dir2_data_entsize(mp, dep->namelen);
+ ptr += xfs_dir2_data_entsize(mp, dep->namelen);
}
/*
* Check the bestfree table.
da_bno, ino);
if (!no_modify) {
do_warn(_("repairing table\n"));
- libxfs_dir2_data_freescan(mp, d, &i);
+ xfs_dir2_data_freescan(mp, d, &i);
*dirty = 1;
} else {
do_warn(_("would repair table\n"));
if (dirty && !no_modify) {
*repair = 1;
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
} else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return rval;
}
struct xfs_dir2_leaf_entry *ents;
struct xfs_dir3_icleaf_hdr leafhdr;
- libxfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
+ xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
ents = leafhdr.ents;
for (i = stale = 0; i < leafhdr.count; i++) {
goto error_out;
}
leaf = bp->b_addr;
- libxfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
+ xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
/*
* Check magic number for leaf directory btree block.
*/
do_warn(
_("bad directory leaf magic # %#x for directory inode %" PRIu64 " block %u\n"),
leafhdr.magic, ino, da_bno);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
buf_dirty = 0;
*/
if (process_leaf_block_dir2(mp, leaf, da_bno, ino,
current_hashval, &greatest_hashval)) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
/*
do_warn(
_("bad sibling back pointer for block %u in directory inode %" PRIu64 "\n"),
da_bno, ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
prev_bno = da_bno;
da_bno = leafhdr.forw;
if (da_bno != 0) {
if (verify_da_path(mp, da_cursor, 0, XFS_DATA_FORK)) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
goto error_out;
}
}
if (buf_dirty && !no_modify) {
*repair = 1;
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
} else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
} while (da_bno != 0);
if (verify_final_da_path(mp, da_cursor, 0, XFS_DATA_FORK)) {
/*
if (dirty && !no_modify) {
*repair = 1;
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
} else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
if (good == 0)
return 1;
int agi_dirty = 0;
int error;
- error = -libxfs_buf_read(mp->m_dev,
+ error = -xfs_buf_read(mp->m_dev,
XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
mp->m_sb.sb_sectsize / BBSIZE, LIBXFS_READBUF_SALVAGE,
&bp, &xfs_agi_buf_ops);
if (agi_dirty) {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
static void
ino_tree_node_t *irec;
if (mp->m_sb.sb_uquotino != NULLFSINO && mp->m_sb.sb_uquotino != 0) {
- if (!libxfs_verify_ino(mp, mp->m_sb.sb_uquotino))
+ if (!xfs_verify_ino(mp, mp->m_sb.sb_uquotino))
irec = NULL;
else
irec = find_inode_rec(mp,
}
if (mp->m_sb.sb_gquotino != NULLFSINO && mp->m_sb.sb_gquotino != 0) {
- if (!libxfs_verify_ino(mp, mp->m_sb.sb_gquotino))
+ if (!xfs_verify_ino(mp, mp->m_sb.sb_gquotino))
irec = NULL;
else
irec = find_inode_rec(mp,
}
if (mp->m_sb.sb_pquotino != NULLFSINO && mp->m_sb.sb_pquotino != 0) {
- if (!libxfs_verify_ino(mp, mp->m_sb.sb_pquotino))
+ if (!xfs_verify_ino(mp, mp->m_sb.sb_pquotino))
irec = NULL;
else
irec = find_inode_rec(mp,
(mp->m_sb.sb_pquotino == NULLFSINO || mp->m_sb.sb_pquotino == 0)) {
lost_quotas = 1;
fs_quotas = 0;
- } else if (libxfs_verify_ino(mp, mp->m_sb.sb_uquotino) &&
- libxfs_verify_ino(mp, mp->m_sb.sb_gquotino) &&
- libxfs_verify_ino(mp, mp->m_sb.sb_pquotino)) {
+ } else if (xfs_verify_ino(mp, mp->m_sb.sb_uquotino) &&
+ xfs_verify_ino(mp, mp->m_sb.sb_gquotino) &&
+ xfs_verify_ino(mp, mp->m_sb.sb_pquotino)) {
fs_quotas = 1;
}
}
curs->level[i].prev_agbno);
#endif
libxfs_buf_mark_dirty(curs->level[i].prev_buf_p);
- libxfs_buf_relse(curs->level[i].prev_buf_p);
+ xfs_buf_relse(curs->level[i].prev_buf_p);
}
libxfs_buf_mark_dirty(curs->level[i].buf_p);
- libxfs_buf_relse(curs->level[i].buf_p);
+ xfs_buf_relse(curs->level[i].buf_p);
}
}
* XXX(hch): any reason we don't just look at mp->m_alloc_mxr?
*/
#define XR_ALLOC_BLOCK_MAXRECS(mp, level) \
- (libxfs_allocbt_maxrecs((mp), (mp)->m_sb.sb_blocksize, (level) == 0) - 2)
+ (xfs_allocbt_maxrecs((mp), (mp)->m_sb.sb_blocksize, (level) == 0) - 2)
/*
* this calculates a freespace cursor for an ag.
if (lptr->prev_agbno != NULLAGBLOCK) {
ASSERT(lptr->prev_buf_p != NULL);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_agbno = lptr->agbno;;
lptr->prev_buf_p = lptr->buf_p;
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, btnum, level,
+ xfs_btree_init_block(mp, lptr->buf_p, btnum, level,
0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
lptr = &btree_curs->level[i];
agbno = get_next_blockaddr(agno, i, btree_curs);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, btnum, i, 0, agno);
+ xfs_btree_init_block(mp, lptr->buf_p, btnum, i, 0, agno);
}
/*
* run along leaf, setting up records. as we have to switch
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, btnum, 0, 0, agno);
+ xfs_btree_init_block(mp, lptr->buf_p, btnum, 0, 0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
bt_hdr->bb_numrecs = cpu_to_be16(lptr->num_recs_pb +
#endif
ASSERT(lptr->prev_agbno != NULLAGBLOCK);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_buf_p = lptr->buf_p;
lptr->prev_agbno = lptr->agbno;
lptr->agbno = get_next_blockaddr(agno, 0, btree_curs);
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(lptr->agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, lptr->agbno),
XFS_FSB_TO_BB(mp, 1),
&lptr->buf_p);
* XXX(hch): any reason we don't just look at mp->m_inobt_mxr?
*/
#define XR_INOBT_BLOCK_MAXRECS(mp, level) \
- libxfs_inobt_maxrecs((mp), (mp)->m_sb.sb_blocksize, \
+ xfs_inobt_maxrecs((mp), (mp)->m_sb.sb_blocksize, \
(level) == 0)
/*
if (lptr->prev_agbno != NULLAGBLOCK) {
ASSERT(lptr->prev_buf_p != NULL);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_agbno = lptr->agbno;;
lptr->prev_buf_p = lptr->buf_p;
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, btnum,
+ xfs_btree_init_block(mp, lptr->buf_p, btnum,
level, 0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
int i;
int error;
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
mp->m_sb.sb_sectsize / BBSIZE, &agi_buf);
if (error)
}
libxfs_buf_mark_dirty(agi_buf);
- libxfs_buf_relse(agi_buf);
+ xfs_buf_relse(agi_buf);
}
/*
lptr = &btree_curs->level[i];
agbno = get_next_blockaddr(agno, i, btree_curs);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, btnum, i, 0, agno);
+ xfs_btree_init_block(mp, lptr->buf_p, btnum, i, 0, agno);
}
/*
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, btnum, 0, 0, agno);
+ xfs_btree_init_block(mp, lptr->buf_p, btnum, 0, 0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
bt_hdr->bb_numrecs = cpu_to_be16(lptr->num_recs_pb +
#endif
ASSERT(lptr->prev_agbno != NULLAGBLOCK);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_buf_p = lptr->buf_p;
lptr->prev_agbno = lptr->agbno;
lptr->agbno = get_next_blockaddr(agno, 0, btree_curs);
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(lptr->agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, lptr->agbno),
XFS_FSB_TO_BB(mp, 1),
&lptr->buf_p);
if (lptr->prev_agbno != NULLAGBLOCK) {
ASSERT(lptr->prev_buf_p != NULL);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_agbno = lptr->agbno;
lptr->prev_buf_p = lptr->buf_p;
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_RMAP,
+ xfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_RMAP,
level, 0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
bt_key->rm_startblock = cpu_to_be32(high_key.rm_startblock);
bt_key->rm_owner = cpu_to_be64(high_key.rm_owner);
bt_key->rm_offset = cpu_to_be64(
- libxfs_rmap_irec_offset_pack(&high_key));
+ xfs_rmap_irec_offset_pack(&high_key));
for (i = 1; i <= numrecs; i++) {
bt_key = XFS_RMAP_HIGH_KEY_ADDR(bt_hdr, i);
lptr = &btree_curs->level[i];
agbno = get_next_blockaddr(agno, i, btree_curs);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_RMAP,
+ xfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_RMAP,
i, 0, agno);
}
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_RMAP,
+ xfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_RMAP,
0, 0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
cpu_to_be32(rm_rec->rm_blockcount);
bt_rec[j].rm_owner = cpu_to_be64(rm_rec->rm_owner);
bt_rec[j].rm_offset = cpu_to_be64(
- libxfs_rmap_irec_offset_pack(rm_rec));
+ xfs_rmap_irec_offset_pack(rm_rec));
rmap_high_key_from_rec(rm_rec, &hi_key);
if (rmap_diffkeys(&hi_key, &highest_key) > 0)
highest_key = hi_key;
#endif
ASSERT(lptr->prev_agbno != NULLAGBLOCK);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_buf_p = lptr->buf_p;
lptr->prev_agbno = lptr->agbno;
lptr->agbno = get_next_blockaddr(agno, 0, btree_curs);
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(lptr->agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, lptr->agbno),
XFS_FSB_TO_BB(mp, 1),
&lptr->buf_p);
if (lptr->prev_agbno != NULLAGBLOCK) {
ASSERT(lptr->prev_buf_p != NULL);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_agbno = lptr->agbno;
lptr->prev_buf_p = lptr->buf_p;
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_REFC,
+ xfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_REFC,
level, 0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
lptr = &btree_curs->level[i];
agbno = get_next_blockaddr(agno, i, btree_curs);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, agbno),
XFS_FSB_TO_BB(mp, 1), &lptr->buf_p);
if (error)
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_REFC,
+ xfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_REFC,
i, 0, agno);
}
lptr->buf_p->b_ops = ops;
bt_hdr = XFS_BUF_TO_BLOCK(lptr->buf_p);
memset(bt_hdr, 0, mp->m_sb.sb_blocksize);
- libxfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_REFC,
+ xfs_btree_init_block(mp, lptr->buf_p, XFS_BTNUM_REFC,
0, 0, agno);
bt_hdr->bb_u.s.bb_leftsib = cpu_to_be32(lptr->prev_agbno);
#endif
ASSERT(lptr->prev_agbno != NULLAGBLOCK);
libxfs_buf_mark_dirty(lptr->prev_buf_p);
- libxfs_buf_relse(lptr->prev_buf_p);
+ xfs_buf_relse(lptr->prev_buf_p);
}
lptr->prev_buf_p = lptr->buf_p;
lptr->prev_agbno = lptr->agbno;
lptr->agbno = get_next_blockaddr(agno, 0, btree_curs);
bt_hdr->bb_u.s.bb_rightsib = cpu_to_be32(lptr->agbno);
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AGB_TO_DADDR(mp, agno, lptr->agbno),
XFS_FSB_TO_BB(mp, 1),
&lptr->buf_p);
__be32 *freelist;
int error;
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
mp->m_sb.sb_sectsize / BBSIZE, &agf_buf);
if (error)
platform_uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
/* initialise the AGFL, then fill it if there are blocks left over. */
- error = -libxfs_buf_get(mp->m_dev,
+ error = -xfs_buf_get(mp->m_dev,
XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
mp->m_sb.sb_sectsize / BBSIZE, &agfl_buf);
if (error)
agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
agfl->agfl_seqno = cpu_to_be32(agno);
platform_uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
- for (i = 0; i < libxfs_agfl_size(mp); i++)
+ for (i = 0; i < xfs_agfl_size(mp); i++)
freelist[i] = cpu_to_be32(NULLAGBLOCK);
}
* yes, now grab as many blocks as we can
*/
i = 0;
- while (bno_bt->num_free_blocks > 0 && i < libxfs_agfl_size(mp))
+ while (bno_bt->num_free_blocks > 0 && i < xfs_agfl_size(mp))
{
freelist[i] = cpu_to_be32(
get_next_blockaddr(agno, 0, bno_bt));
i++;
}
- while (bcnt_bt->num_free_blocks > 0 && i < libxfs_agfl_size(mp))
+ while (bcnt_bt->num_free_blocks > 0 && i < xfs_agfl_size(mp))
{
freelist[i] = cpu_to_be32(
get_next_blockaddr(agno, 0, bcnt_bt));
} else {
agf->agf_flfirst = 0;
- agf->agf_fllast = cpu_to_be32(libxfs_agfl_size(mp) - 1);
+ agf->agf_fllast = cpu_to_be32(xfs_agfl_size(mp) - 1);
agf->agf_flcount = 0;
}
libxfs_buf_mark_dirty(agfl_buf);
- libxfs_buf_relse(agfl_buf);
+ xfs_buf_relse(agfl_buf);
ext_ptr = findbiggest_bcnt_extent(agno);
agf->agf_longest = cpu_to_be32((ext_ptr != NULL) ?
be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNTi]));
libxfs_buf_mark_dirty(agf_buf);
- libxfs_buf_relse(agf_buf);
+ xfs_buf_relse(agf_buf);
/*
* now fix up the free list appropriately
update_sb_version(mp);
- libxfs_sb_to_disk(bp->b_addr, &mp->m_sb);
+ xfs_sb_to_disk(bp->b_addr, &mp->m_sb);
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
/*
/*
* see if we can fit all the extra blocks into the AGFL
*/
- extra_blocks = (extra_blocks - libxfs_agfl_size(mp) > 0)
- ? extra_blocks - libxfs_agfl_size(mp)
+ extra_blocks = (extra_blocks - xfs_agfl_size(mp) > 0)
+ ? extra_blocks - xfs_agfl_size(mp)
: 0;
if (extra_blocks > 0)
return error;
while ((fsb = pop_slab_cursor(cur)) != NULL) {
- error = -libxfs_trans_alloc_rollable(mp, 16, &tp);
+ error = -xfs_trans_alloc_rollable(mp, 16, &tp);
if (error)
goto out_cancel;
- error = -libxfs_free_extent(tp, *fsb, 1, &XFS_RMAP_OINFO_AG,
+ error = -xfs_free_extent(tp, *fsb, 1, &XFS_RMAP_OINFO_AG,
XFS_AG_RESV_NONE);
if (error)
goto out_cancel;
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
goto out_cancel;
tp = NULL;
out_cancel:
if (tp)
- libxfs_trans_cancel(tp);
+ xfs_trans_cancel(tp);
free_slab_cursor(&cur);
return error;
}
#ifdef XR_BLD_FREE_TRACE
fprintf(stderr, "inobt level 1, maxrec = %d, minrec = %d\n",
- libxfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 0),
- libxfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 0) / 2);
+ xfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 0),
+ xfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 0) / 2);
fprintf(stderr, "inobt level 0 (leaf), maxrec = %d, minrec = %d\n",
- libxfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 1),
- libxfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 1) / 2);
+ xfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 1),
+ xfs_inobt_maxrecs(mp, mp->m_sb.sb_blocksize, 1) / 2);
fprintf(stderr, "xr inobt level 0 (leaf), maxrec = %d\n",
XR_INOBT_BLOCK_MAXRECS(mp, 0));
fprintf(stderr, "xr inobt level 1 (int), maxrec = %d\n",
XR_INOBT_BLOCK_MAXRECS(mp, 1));
fprintf(stderr, "bnobt level 1, maxrec = %d, minrec = %d\n",
- libxfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0),
- libxfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0) / 2);
+ xfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0),
+ xfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0) / 2);
fprintf(stderr, "bnobt level 0 (leaf), maxrec = %d, minrec = %d\n",
- libxfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 1),
- libxfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 1) / 2);
+ xfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 1),
+ xfs_allocbt_maxrecs(mp, mp->m_sb.sb_blocksize, 1) / 2);
#endif
/*
* make sure the root and realtime inodes show up allocated
*/
if (size > offsetof(struct xfs_dir2_sf_hdr, parent) &&
size >= xfs_dir2_sf_hdr_size(sfp->i8count)) {
- old_parent = libxfs_dir2_sf_get_parent_ino(sfp);
+ old_parent = xfs_dir2_sf_get_parent_ino(sfp);
if (old_parent == 0) {
- libxfs_dir2_sf_put_parent_ino(sfp, mp->m_sb.sb_rootino);
+ xfs_dir2_sf_put_parent_ino(sfp, mp->m_sb.sb_rootino);
parent_bypass = true;
}
}
- fa = libxfs_default_ifork_ops.verify_dir(ip);
+ fa = xfs_default_ifork_ops.verify_dir(ip);
/* Put it back. */
if (parent_bypass)
- libxfs_dir2_sf_put_parent_ino(sfp, old_parent);
+ xfs_dir2_sf_put_parent_ino(sfp, old_parent);
return fa;
}
int error;
int error2;
- error = -libxfs_da_read_buf(NULL, ip, bno, 0, bpp, XFS_DATA_FORK, ops);
+ error = -xfs_da_read_buf(NULL, ip, bno, 0, bpp, XFS_DATA_FORK, ops);
if (error != EFSBADCRC && error != EFSCORRUPTED)
return error;
- error2 = -libxfs_da_read_buf(NULL, ip, bno, 0, bpp, XFS_DATA_FORK,
+ error2 = -xfs_da_read_buf(NULL, ip, bno, 0, bpp, XFS_DATA_FORK,
NULL);
if (error2)
return error2;
dup = 0;
if (!junk) {
- hash = libxfs_dir2_hashname(mp, &xname);
+ hash = xfs_dir2_hashname(mp, &xname);
byhash = DIR_HASH_FUNC(hashtab, hash);
/*
}
ifp = XFS_IFORK_PTR(ip, whichfork);
if (!(ifp->if_flags & XFS_IFEXTENTS) &&
- (error = -libxfs_iread_extents(tp, ip, whichfork)))
+ (error = -xfs_iread_extents(tp, ip, whichfork)))
return error;
bno = *bnop + 1;
- if (!libxfs_iext_lookup_extent(ip, ifp, bno, &icur, &got))
+ if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got))
*bnop = NULLFILEOFF;
else
*bnop = got.br_startoff < bno ? bno : got.br_startoff;
/*
* first set up inode
*/
- i = -libxfs_trans_alloc_rollable(mp, 10, &tp);
+ i = -xfs_trans_alloc_rollable(mp, 10, &tp);
if (i)
res_failed(i);
ip->i_d.di_flags2 = 0;
times |= XFS_ICHGTIME_CREATE;
}
- libxfs_trans_ichgtime(tp, ip, times);
+ xfs_trans_ichgtime(tp, ip, times);
/*
* now the ifork
/*
* commit changes
*/
- libxfs_trans_ijoin(tp, ip, 0);
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(_("%s: commit failed, error %d\n"), __func__, error);
*/
blocks = mp->m_sb.sb_rbmblocks +
XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 1;
- error = -libxfs_trans_alloc_rollable(mp, blocks, &tp);
+ error = -xfs_trans_alloc_rollable(mp, blocks, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
bno = 0;
while (bno < mp->m_sb.sb_rbmblocks) {
nmap = XFS_BMAP_MAX_NMAP;
- error = -libxfs_bmapi_write(tp, ip, bno,
+ error = -xfs_bmapi_write(tp, ip, bno,
(xfs_extlen_t)(mp->m_sb.sb_rbmblocks - bno),
0, mp->m_sb.sb_rbmblocks, map, &nmap);
if (error) {
bno += ep->br_blockcount;
}
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error) {
do_error(
_("allocation of the realtime bitmap failed, error = %d\n"),
bmp = btmcompute;
bno = 0;
- error = -libxfs_trans_alloc_rollable(mp, 10, &tp);
+ error = -xfs_trans_alloc_rollable(mp, 10, &tp);
if (error)
res_failed(error);
* fill the file one block at a time
*/
nmap = 1;
- error = -libxfs_bmapi_write(tp, ip, bno, 1, 0, 1, &map, &nmap);
+ error = -xfs_bmapi_write(tp, ip, bno, 1, 0, 1, &map, &nmap);
if (error || nmap != 1) {
do_error(
_("couldn't map realtime bitmap block %" PRIu64 ", error = %d\n"),
ASSERT(map.br_startblock != HOLESTARTBLOCK);
- error = -libxfs_trans_read_buf(
+ error = -xfs_trans_read_buf(
mp, tp, mp->m_dev,
XFS_FSB_TO_DADDR(mp, map.br_startblock),
XFS_FSB_TO_BB(mp, 1), 1, &bp, NULL);
memmove(bp->b_addr, bmp, mp->m_sb.sb_blocksize);
- libxfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1);
+ xfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1);
bmp = (xfs_rtword_t *)((intptr_t) bmp + mp->m_sb.sb_blocksize);
bno++;
}
- libxfs_trans_ijoin(tp, ip, 0);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_ijoin(tp, ip, 0);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(_("%s: commit failed, error %d\n"), __func__, error);
libxfs_irele(ip);
bno = 0;
end_bno = mp->m_rsumsize >> mp->m_sb.sb_blocklog;
- error = -libxfs_trans_alloc_rollable(mp, 10, &tp);
+ error = -xfs_trans_alloc_rollable(mp, 10, &tp);
if (error)
res_failed(error);
* fill the file one block at a time
*/
nmap = 1;
- error = -libxfs_bmapi_write(tp, ip, bno, 1, 0, 1, &map, &nmap);
+ error = -xfs_bmapi_write(tp, ip, bno, 1, 0, 1, &map, &nmap);
if (error || nmap != 1) {
do_error(
_("couldn't map realtime summary inode block %" PRIu64 ", error = %d\n"),
ASSERT(map.br_startblock != HOLESTARTBLOCK);
- error = -libxfs_trans_read_buf(
+ error = -xfs_trans_read_buf(
mp, tp, mp->m_dev,
XFS_FSB_TO_DADDR(mp, map.br_startblock),
XFS_FSB_TO_BB(mp, 1), 1, &bp, NULL);
memmove(bp->b_addr, smp, mp->m_sb.sb_blocksize);
- libxfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1);
+ xfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1);
smp = (xfs_suminfo_t *)((intptr_t)smp + mp->m_sb.sb_blocksize);
bno++;
}
- libxfs_trans_ijoin(tp, ip, 0);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_ijoin(tp, ip, 0);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(_("%s: commit failed, error %d\n"), __func__, error);
libxfs_irele(ip);
/*
* first set up inode
*/
- i = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 10, 0, 0, &tp);
+ i = -xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 10, 0, 0, &tp);
if (i)
res_failed(i);
ip->i_d.di_flags2 = 0;
times |= XFS_ICHGTIME_CREATE;
}
- libxfs_trans_ichgtime(tp, ip, times);
+ xfs_trans_ichgtime(tp, ip, times);
/*
* now the ifork
/*
* commit changes
*/
- libxfs_trans_ijoin(tp, ip, 0);
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(_("%s: commit failed, error %d\n"), __func__, error);
*/
nsumblocks = mp->m_rsumsize >> mp->m_sb.sb_blocklog;
blocks = nsumblocks + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 1;
- error = -libxfs_trans_alloc_rollable(mp, blocks, &tp);
+ error = -xfs_trans_alloc_rollable(mp, blocks, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
bno = 0;
while (bno < nsumblocks) {
nmap = XFS_BMAP_MAX_NMAP;
- error = -libxfs_bmapi_write(tp, ip, bno,
+ error = -xfs_bmapi_write(tp, ip, bno,
(xfs_extlen_t)(nsumblocks - bno),
0, nsumblocks, map, &nmap);
if (error) {
bno += ep->br_blockcount;
}
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error) {
do_error(
_("allocation of the realtime summary ino failed, error = %d\n"),
int times;
ip = NULL;
- i = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 10, 0, 0, &tp);
+ i = -xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 10, 0, 0, &tp);
if (i)
res_failed(i);
ip->i_d.di_flags2 = 0;
times |= XFS_ICHGTIME_CREATE;
}
- libxfs_trans_ichgtime(tp, ip, times);
- libxfs_trans_ijoin(tp, ip, 0);
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ xfs_trans_ichgtime(tp, ip, times);
+ xfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
/*
* now the ifork
/*
* initialize the directory
*/
- libxfs_dir_init(tp, ip, ip);
+ xfs_dir_init(tp, ip, ip);
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(_("%s: commit failed, error %d\n"), __func__, error);
xname.len = strlen(ORPHANAGE);
xname.type = XFS_DIR3_FT_DIR;
- if (libxfs_dir_lookup(NULL, pip, &xname, &ino, NULL) == 0)
+ if (xfs_dir_lookup(NULL, pip, &xname, &ino, NULL) == 0)
return ino;
/*
* could not be found, create it
*/
nres = XFS_MKDIR_SPACE_RES(mp, xname.len);
- i = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_mkdir, nres, 0, 0, &tp);
+ i = -xfs_trans_alloc(mp, &M_RES(mp)->tr_mkdir, nres, 0, 0, &tp);
if (i)
res_failed(i);
do_error(_("%d - couldn't iget root inode to make %s\n"),
i, ORPHANAGE);*/
- error = -libxfs_inode_alloc(&tp, pip, mode|S_IFDIR,
+ error = -xfs_inode_alloc(&tp, pip, mode|S_IFDIR,
1, 0, &zerocr, &zerofsx, &ip);
if (error) {
do_error(_("%s inode allocation failed %d\n"),
* now that we know the transaction will stay around,
* add the root inode to it
*/
- libxfs_trans_ijoin(tp, pip, 0);
+ xfs_trans_ijoin(tp, pip, 0);
/*
* create the actual entry
*/
- error = -libxfs_dir_createname(tp, pip, &xname, ip->i_ino, nres);
+ error = -xfs_dir_createname(tp, pip, &xname, ip->i_ino, nres);
if (error)
do_error(
_("can't make %s, createname error %d\n"),
add_inode_ref(irec, 0);
set_inode_disk_nlinks(irec, 0, get_inode_disk_nlinks(irec, 0) + 1);
- libxfs_trans_log_inode(tp, pip, XFS_ILOG_CORE);
- libxfs_dir_init(tp, ip, pip);
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, pip, XFS_ILOG_CORE);
+ xfs_dir_init(tp, ip, pip);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ error = -xfs_trans_commit(tp);
if (error) {
do_error(_("%s directory creation failed -- bmapf error %d\n"),
ORPHANAGE, error);
* Make sure the filename is unique in the lost+found
*/
incr = 0;
- while (libxfs_dir_lookup(NULL, orphanage_ip, &xname, &entry_ino_num,
+ while (xfs_dir_lookup(NULL, orphanage_ip, &xname, &entry_ino_num,
NULL) == 0)
xname.len = snprintf((char *)fname, sizeof(fname), "%llu.%d",
(unsigned long long)ino, ++incr);
if (err)
do_error(_("%d - couldn't iget disconnected inode\n"), err);
- xname.type = libxfs_mode_to_ftype(VFS_I(ino_p)->i_mode);
+ xname.type = xfs_mode_to_ftype(VFS_I(ino_p)->i_mode);
if (isa_dir) {
irec = find_inode_rec(mp, XFS_INO_TO_AGNO(mp, orphanage_ino),
irec->ino_startnum;
nres = XFS_DIRENTER_SPACE_RES(mp, fnamelen) +
XFS_DIRENTER_SPACE_RES(mp, 2);
- err = -libxfs_dir_lookup(NULL, ino_p, &xfs_name_dotdot,
+ err = -xfs_dir_lookup(NULL, ino_p, &xfs_name_dotdot,
&entry_ino_num, NULL);
if (err) {
ASSERT(err == ENOENT);
- err = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_rename,
+ err = -xfs_trans_alloc(mp, &M_RES(mp)->tr_rename,
nres, 0, 0, &tp);
if (err)
do_error(
_("space reservation failed (%d), filesystem may be out of space\n"),
err);
- libxfs_trans_ijoin(tp, orphanage_ip, 0);
- libxfs_trans_ijoin(tp, ino_p, 0);
+ xfs_trans_ijoin(tp, orphanage_ip, 0);
+ xfs_trans_ijoin(tp, ino_p, 0);
- err = -libxfs_dir_createname(tp, orphanage_ip, &xname,
+ err = -xfs_dir_createname(tp, orphanage_ip, &xname,
ino, nres);
if (err)
do_error(
add_inode_ref(irec, ino_offset);
else
inc_nlink(VFS_I(orphanage_ip));
- libxfs_trans_log_inode(tp, orphanage_ip, XFS_ILOG_CORE);
+ xfs_trans_log_inode(tp, orphanage_ip, XFS_ILOG_CORE);
- err = -libxfs_dir_createname(tp, ino_p, &xfs_name_dotdot,
+ err = -xfs_dir_createname(tp, ino_p, &xfs_name_dotdot,
orphanage_ino, nres);
if (err)
do_error(
err);
inc_nlink(VFS_I(ino_p));
- libxfs_trans_log_inode(tp, ino_p, XFS_ILOG_CORE);
- err = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ino_p, XFS_ILOG_CORE);
+ err = -xfs_trans_commit(tp);
if (err)
do_error(
_("creation of .. entry failed (%d)\n"), err);
} else {
- err = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_rename,
+ err = -xfs_trans_alloc(mp, &M_RES(mp)->tr_rename,
nres, 0, 0, &tp);
if (err)
do_error(
_("space reservation failed (%d), filesystem may be out of space\n"),
err);
- libxfs_trans_ijoin(tp, orphanage_ip, 0);
- libxfs_trans_ijoin(tp, ino_p, 0);
+ xfs_trans_ijoin(tp, orphanage_ip, 0);
+ xfs_trans_ijoin(tp, ino_p, 0);
- err = -libxfs_dir_createname(tp, orphanage_ip, &xname,
+ err = -xfs_dir_createname(tp, orphanage_ip, &xname,
ino, nres);
if (err)
do_error(
add_inode_ref(irec, ino_offset);
else
inc_nlink(VFS_I(orphanage_ip));
- libxfs_trans_log_inode(tp, orphanage_ip, XFS_ILOG_CORE);
+ xfs_trans_log_inode(tp, orphanage_ip, XFS_ILOG_CORE);
/*
* don't replace .. value if it already points
* to us. that'll pop a libxfs/kernel ASSERT.
*/
if (entry_ino_num != orphanage_ino) {
- err = -libxfs_dir_replace(tp, ino_p,
+ err = -xfs_dir_replace(tp, ino_p,
&xfs_name_dotdot, orphanage_ino,
nres);
if (err)
err);
}
- err = -libxfs_trans_commit(tp);
+ err = -xfs_trans_commit(tp);
if (err)
do_error(
_("orphanage name replace op failed (%d)\n"), err);
* also accounted for in the create
*/
nres = XFS_DIRENTER_SPACE_RES(mp, xname.len);
- err = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_remove,
+ err = -xfs_trans_alloc(mp, &M_RES(mp)->tr_remove,
nres, 0, 0, &tp);
if (err)
do_error(
_("space reservation failed (%d), filesystem may be out of space\n"),
err);
- libxfs_trans_ijoin(tp, orphanage_ip, 0);
- libxfs_trans_ijoin(tp, ino_p, 0);
+ xfs_trans_ijoin(tp, orphanage_ip, 0);
+ xfs_trans_ijoin(tp, ino_p, 0);
- err = -libxfs_dir_createname(tp, orphanage_ip, &xname, ino,
+ err = -xfs_dir_createname(tp, orphanage_ip, &xname, ino,
nres);
if (err)
do_error(
ASSERT(err == 0);
set_nlink(VFS_I(ino_p), 1);
- libxfs_trans_log_inode(tp, ino_p, XFS_ILOG_CORE);
- err = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ino_p, XFS_ILOG_CORE);
+ err = -xfs_trans_commit(tp);
if (err)
do_error(
_("orphanage name create failed (%d)\n"), err);
dabno < rec.br_startoff + rec.br_blockcount;
dabno += geo->fsbcount) {
bp = NULL;
- error = -libxfs_da_get_buf(tp, ip, dabno, &bp,
+ error = -xfs_da_get_buf(tp, ip, dabno, &bp,
whichfork);
if (error)
return error;
if (!bp)
continue;
- libxfs_trans_binval(tp, bp);
- libxfs_trans_brelse(tp, bp);
+ xfs_trans_binval(tp, bp);
+ xfs_trans_brelse(tp, bp);
}
}
* first attempt to locate the parent inode, if it can't be
* found, set it to the root inode and it'll be moved to the
* orphanage later (the inode number here needs to be valid
- * for the libxfs_dir_init() call).
+ * for the xfs_dir_init() call).
*/
pip.i_ino = get_inode_parent(irec, ino_offset);
if (pip.i_ino == NULLFSINO ||
- libxfs_dir_ino_validate(mp, pip.i_ino))
+ xfs_dir_ino_validate(mp, pip.i_ino))
pip.i_ino = mp->m_sb.sb_rootino;
nres = XFS_REMOVE_SPACE_RES(mp);
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_remove, nres, 0, 0, &tp);
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, nres, 0, 0, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
error = dir_binval(tp, ip, XFS_DATA_FORK);
if (error)
do_error(_("error %d invalidating directory %llu blocks\n"),
error, (unsigned long long)ip->i_ino);
- if ((error = -libxfs_bmap_last_offset(ip, &lastblock, XFS_DATA_FORK)))
+ if ((error = -xfs_bmap_last_offset(ip, &lastblock, XFS_DATA_FORK)))
do_error(_("xfs_bmap_last_offset failed -- error - %d\n"),
error);
/* free all data, leaf, node and freespace blocks */
while (!done) {
- error = -libxfs_bunmapi(tp, ip, 0, lastblock, XFS_BMAPI_METADATA,
+ error = -xfs_bunmapi(tp, ip, 0, lastblock, XFS_BMAPI_METADATA,
0, &done);
if (error) {
do_warn(_("xfs_bunmapi failed -- error - %d\n"), error);
goto out_bmap_cancel;
}
- error = -libxfs_defer_finish(&tp);
+ error = -xfs_defer_finish(&tp);
if (error) {
do_warn(("defer_finish failed -- error - %d\n"), error);
goto out_bmap_cancel;
/*
* Close out trans and start the next one in the chain.
*/
- error = -libxfs_trans_roll_inode(&tp, ip);
+ error = -xfs_trans_roll_inode(&tp, ip);
if (error)
goto out_bmap_cancel;
}
- error = -libxfs_dir_init(tp, ip, &pip);
+ error = -xfs_dir_init(tp, ip, &pip);
if (error) {
do_warn(_("xfs_dir_init failed -- error - %d\n"), error);
goto out_bmap_cancel;
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(
_("dir init failed (%d)\n"), error);
continue;
nres = XFS_CREATE_SPACE_RES(mp, p->name.len);
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_create,
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_create,
nres, 0, 0, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
- error = -libxfs_dir_createname(tp, ip, &p->name, p->inum,
+ error = -xfs_dir_createname(tp, ip, &p->name, p->inum,
nres);
if (error) {
do_warn(
goto out_bmap_cancel;
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(
_("name create failed (%d) during rebuild\n"), error);
return;
out_bmap_cancel:
- libxfs_trans_cancel(tp);
+ xfs_trans_cancel(tp);
return;
}
xfs_trans_t *tp;
nres = XFS_REMOVE_SPACE_RES(mp);
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_remove, nres, 0, 0, &tp);
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, nres, 0, 0, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
- libxfs_trans_bjoin(tp, bp);
+ xfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_bjoin(tp, bp);
memset(&args, 0, sizeof(args));
args.dp = ip;
args.trans = tp;
args.whichfork = XFS_DATA_FORK;
args.geo = mp->m_dir_geo;
if (da_bno >= mp->m_dir_geo->leafblk && da_bno < mp->m_dir_geo->freeblk)
- error = -libxfs_da_shrink_inode(&args, da_bno, bp);
+ error = -xfs_da_shrink_inode(&args, da_bno, bp);
else
- error = -libxfs_dir2_shrink_inode(&args,
+ error = -xfs_dir2_shrink_inode(&args,
xfs_dir2_da_to_db(mp->m_dir_geo, da_bno), bp);
if (error)
do_error(_("shrink_inode failed inode %" PRIu64 " block %u\n"),
ip->i_ino, da_bno);
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(
_("directory shrink failed (%d)\n"), error);
/* validate data entry size */
dep = (xfs_dir2_data_entry_t *)ptr;
- if (ptr + libxfs_dir2_data_entsize(mp, dep->namelen) > endptr)
+ if (ptr + xfs_dir2_data_entsize(mp, dep->namelen) > endptr)
break;
- if (be16_to_cpu(*libxfs_dir2_data_entry_tag_p(mp, dep)) !=
+ if (be16_to_cpu(*xfs_dir2_data_entry_tag_p(mp, dep)) !=
(char *)dep - (char *)d)
break;
- ptr += libxfs_dir2_data_entsize(mp, dep->namelen);
+ ptr += xfs_dir2_data_entsize(mp, dep->namelen);
}
/* did we find an empty or corrupt block? */
dir2_kill_block(mp, ip, da_bno, bp);
} else {
do_warn(_("would junk block\n"));
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
freetab->ents[db].v = NULLDATAOFF;
*bpp = NULL;
if (freetab->nents < db + 1)
freetab->nents = db + 1;
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_remove, 0, 0, 0, &tp);
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, 0, 0, 0, &tp);
if (error)
res_failed(error);
da.trans = tp;
- libxfs_trans_ijoin(tp, ip, 0);
- libxfs_trans_bjoin(tp, bp);
- libxfs_trans_bhold(tp, bp);
+ xfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_bjoin(tp, bp);
+ xfs_trans_bhold(tp, bp);
if (be32_to_cpu(d->magic) != wantmagic) {
do_warn(
_("bad directory block magic # %#x for directory inode %" PRIu64 " block %d: "),
do_warn(_("joining together\n"));
len = be16_to_cpu(dup->length);
- libxfs_dir2_data_use_free(&da, bp, dup,
+ xfs_dir2_data_use_free(&da, bp, dup,
ptr - (char *)d, len, &needlog,
&needscan);
- libxfs_dir2_data_make_free(&da, bp,
+ xfs_dir2_data_make_free(&da, bp,
ptr - (char *)d, len, &needlog,
&needscan);
} else
addr = xfs_dir2_db_off_to_dataptr(mp->m_dir_geo, db,
ptr - (char *)d);
dep = (xfs_dir2_data_entry_t *)ptr;
- ptr += libxfs_dir2_data_entsize(mp, dep->namelen);
+ ptr += xfs_dir2_data_entsize(mp, dep->namelen);
inum = be64_to_cpu(dep->inumber);
lastfree = 0;
/*
if (dep->name[0] == '/') {
nbad++;
if (!no_modify)
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
continue;
}
_("entry \"%s\" in directory inode %" PRIu64 " points to non-existent inode %" PRIu64 ""),
fname, ip->i_ino, inum)) {
dep->name[0] = '/';
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
}
continue;
}
_("entry \"%s\" in directory inode %" PRIu64 " points to free inode %" PRIu64),
fname, ip->i_ino, inum)) {
dep->name[0] = '/';
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
}
continue;
}
_("%s (ino %" PRIu64 ") in root (%" PRIu64 ") is not a directory"),
ORPHANAGE, inum, ip->i_ino)) {
dep->name[0] = '/';
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
}
continue;
}
* check for duplicate names in directory.
*/
if (!dir_hash_add(mp, hashtab, addr, inum, dep->namelen,
- dep->name, libxfs_dir2_data_get_ftype(mp, dep))) {
+ dep->name, xfs_dir2_data_get_ftype(mp, dep))) {
nbad++;
if (entry_junked(
_("entry \"%s\" (ino %" PRIu64 ") in dir %" PRIu64 " is a duplicate name"),
fname, inum, ip->i_ino)) {
dep->name[0] = '/';
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
}
if (inum == orphanage_ino)
orphanage_ino = 0;
_("entry \"%s\" (ino %" PRIu64 ") in dir %" PRIu64 " is not in the the first block"), fname,
inum, ip->i_ino)) {
dep->name[0] = '/';
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
}
}
continue;
}
- ASSERT(no_modify || libxfs_verify_dir_ino(mp, inum));
+ ASSERT(no_modify || xfs_verify_dir_ino(mp, inum));
/*
* special case the . entry. we know there's only one
* '.' and only '.' points to itself because bogus entries
_("entry \"%s\" in dir %" PRIu64 " is not the first entry"),
fname, inum, ip->i_ino)) {
dep->name[0] = '/';
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
}
}
*need_dot = 0;
/*
* skip entries with bogus inumbers if we're in no modify mode
*/
- if (no_modify && !libxfs_verify_dir_ino(mp, inum))
+ if (no_modify && !xfs_verify_dir_ino(mp, inum))
continue;
/* validate ftype field if supported */
uint8_t dir_ftype;
uint8_t ino_ftype;
- dir_ftype = libxfs_dir2_data_get_ftype(mp, dep);
+ dir_ftype = xfs_dir2_data_get_ftype(mp, dep);
ino_ftype = get_inode_ftype(irec, ino_offset);
if (dir_ftype != ino_ftype) {
_("fixing ftype mismatch (%d/%d) in directory/child inode %" PRIu64 "/%" PRIu64 "\n"),
dir_ftype, ino_ftype,
ip->i_ino, inum);
- libxfs_dir2_data_put_ftype(mp, dep, ino_ftype);
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_put_ftype(mp, dep, ino_ftype);
+ xfs_dir2_data_log_entry(&da, bp, dep);
dir_hash_update_ftype(hashtab, addr,
ino_ftype);
}
nbad++;
if (!no_modify) {
dep->name[0] = '/';
- libxfs_dir2_data_log_entry(&da, bp, dep);
+ xfs_dir2_data_log_entry(&da, bp, dep);
if (verbose)
do_warn(
_("\twill clear entry \"%s\"\n"),
}
*num_illegal += nbad;
if (needscan)
- libxfs_dir2_data_freescan(mp, d, &i);
+ xfs_dir2_data_freescan(mp, d, &i);
if (needlog)
- libxfs_dir2_data_log_header(&da, bp);
- error = -libxfs_trans_commit(tp);
+ xfs_dir2_data_log_header(&da, bp);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(
_("directory block fixing failed (%d)\n"), error);
/* record the largest free space in the freetab for later checking */
- bf = libxfs_dir2_data_bestfree_p(mp, d);
+ bf = xfs_dir2_data_bestfree_p(mp, d);
freetab->ents[db].v = be16_to_cpu(bf[0].length);
freetab->ents[db].s = 0;
}
}
leaf = bp->b_addr;
- libxfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
+ xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
ents = leafhdr.ents;
ltp = xfs_dir2_leaf_tail_p(mp->m_dir_geo, leaf);
bestsp = xfs_dir2_leaf_bests_p(ltp);
do_warn(
_("leaf block %u for directory inode %" PRIu64 " bad header\n"),
da_bno, ip->i_ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
if (leafhdr.magic == XFS_DIR3_LEAF1_MAGIC) {
error = check_da3_header(mp, bp, ip->i_ino);
if (error) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
}
seeval = dir_hash_see_all(hashtab, ents, leafhdr.count, leafhdr.stale);
if (dir_hash_check(hashtab, ip, seeval)) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
badtail = freetab->nents != be32_to_cpu(ltp->bestcount);
do_warn(
_("leaf block %u for directory inode %" PRIu64 " bad tail\n"),
da_bno, ip->i_ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return fixit;
}
return 1;
}
leaf = bp->b_addr;
- libxfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
+ xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
ents = leafhdr.ents;
if (!(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
leafhdr.magic == XFS_DIR3_LEAFN_MAGIC ||
do_warn(
_("unknown magic number %#x for block %u in directory inode %" PRIu64 "\n"),
leafhdr.magic, da_bno, ip->i_ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
leafhdr.magic == XFS_DA3_NODE_MAGIC) {
error = check_da3_header(mp, bp, ip->i_ino);
if (error) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
}
/* ignore nodes */
if (leafhdr.magic == XFS_DA_NODE_MAGIC ||
leafhdr.magic == XFS_DA3_NODE_MAGIC) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
continue;
}
do_warn(
_("leaf block %u for directory inode %" PRIu64 " bad header\n"),
da_bno, ip->i_ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
seeval = dir_hash_see_all(hashtab, ents,
leafhdr.count, leafhdr.stale);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
if (seeval != DIR_HASH_CK_OK)
return 1;
}
return 1;
}
free = bp->b_addr;
- libxfs_dir2_free_hdr_from_disk(mp, &freehdr, free);
+ xfs_dir2_free_hdr_from_disk(mp, &freehdr, free);
bests = freehdr.bests;
fdb = xfs_dir2_da_to_db(mp->m_dir_geo, da_bno);
if (!(freehdr.magic == XFS_DIR2_FREE_MAGIC ||
do_warn(
_("free block %u for directory inode %" PRIu64 " bad header\n"),
da_bno, ip->i_ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
if (freehdr.magic == XFS_DIR3_FREE_MAGIC) {
error = check_dir3_header(mp, bp, ip->i_ino);
if (error) {
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return error;
}
}
do_warn(
_("free block %u entry %i for directory ino %" PRIu64 " bad\n"),
da_bno, i, ip->i_ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
used += be16_to_cpu(bests[i]) != NULLDATAOFF;
do_warn(
_("free block %u for directory inode %" PRIu64 " bad nused\n"),
da_bno, ip->i_ino);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 1;
}
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
for (i = 0; i < freetab->nents; i++) {
if ((freetab->ents[i].s == 0) &&
/* is this a block, leaf, or node directory? */
args.dp = ip;
args.geo = mp->m_dir_geo;
- libxfs_dir2_isblock(&args, &isblock);
- libxfs_dir2_isleaf(&args, &isleaf);
+ xfs_dir2_isblock(&args, &isblock);
+ xfs_dir2_isleaf(&args, &isleaf);
/* check directory "data" blocks (ie. name/inode pairs) */
for (da_bno = 0, next_da_bno = 0;
dir_hash_dup_names(hashtab);
for (i = 0; i < num_bps; i++)
if (bplist[i])
- libxfs_buf_relse(bplist[i]);
+ xfs_buf_relse(bplist[i]);
longform_dir2_rebuild(mp, ino, ip, irec, ino_offset, hashtab);
*num_illegal = 0;
*need_dot = 0;
} else {
for (i = 0; i < num_bps; i++)
if (bplist[i])
- libxfs_buf_relse(bplist[i]);
+ xfs_buf_relse(bplist[i]);
}
free(bplist);
if (lino == orphanage_ino)
orphanage_ino = 0;
- next_elen = libxfs_dir2_sf_entsize(mp, sfp, sfep->namelen);
- next_sfep = libxfs_dir2_sf_nextentry(mp, sfp, sfep);
+ next_elen = xfs_dir2_sf_entsize(mp, sfp, sfep->namelen);
+ next_sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep);
/*
* if we are just checking, simply return the pointer to the next entry
do_warn(
_("setting .. in sf dir inode %" PRIu64 " to %" PRIu64 "\n"),
ino, parent);
- libxfs_dir2_sf_put_parent_ino(sfp, parent);
+ xfs_dir2_sf_put_parent_ino(sfp, parent);
*ino_dirty = 1;
}
return;
/*
* Initialise i8 counter -- the parent inode number counts as well.
*/
- i8 = libxfs_dir2_sf_get_parent_ino(sfp) > XFS_DIR2_MAX_SHORT_INUM;
+ i8 = xfs_dir2_sf_get_parent_ino(sfp) > XFS_DIR2_MAX_SHORT_INUM;
/*
* now run through entries, stop at first bad entry, don't need
sfep = next_sfep, i++) {
bad_sfnamelen = 0;
- lino = libxfs_dir2_sf_get_ino(mp, sfp, sfep);
+ lino = xfs_dir2_sf_get_ino(mp, sfp, sfep);
namelen = sfep->namelen;
break;
}
} else if (no_modify && (intptr_t) sfep - (intptr_t) sfp +
- + libxfs_dir2_sf_entsize(mp, sfp, sfep->namelen)
+ + xfs_dir2_sf_entsize(mp, sfp, sfep->namelen)
> ip->i_d.di_size) {
bad_sfnamelen = 1;
fname[sfep->namelen] = '\0';
ASSERT(no_modify || (lino != NULLFSINO && lino != 0));
- ASSERT(no_modify || libxfs_verify_dir_ino(mp, lino));
+ ASSERT(no_modify || xfs_verify_dir_ino(mp, lino));
/*
* Also skip entries with bogus inode numbers if we're
* in no modify mode.
*/
- if (no_modify && !libxfs_verify_dir_ino(mp, lino)) {
- next_sfep = libxfs_dir2_sf_nextentry(mp, sfp, sfep);
+ if (no_modify && !xfs_verify_dir_ino(mp, lino)) {
+ next_sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep);
continue;
}
if (!dir_hash_add(mp, hashtab, (xfs_dir2_dataptr_t)
(sfep - xfs_dir2_sf_firstentry(sfp)),
lino, sfep->namelen, sfep->name,
- libxfs_dir2_sf_get_ftype(mp, sfep))) {
+ xfs_dir2_sf_get_ftype(mp, sfep))) {
do_warn(
_("entry \"%s\" (ino %" PRIu64 ") in dir %" PRIu64 " is a duplicate name"),
fname, lino, ino);
uint8_t dir_ftype;
uint8_t ino_ftype;
- dir_ftype = libxfs_dir2_sf_get_ftype(mp, sfep);
+ dir_ftype = xfs_dir2_sf_get_ftype(mp, sfep);
ino_ftype = get_inode_ftype(irec, ino_offset);
if (dir_ftype != ino_ftype) {
_("fixing ftype mismatch (%d/%d) in directory/child inode %" PRIu64 "/%" PRIu64 "\n"),
dir_ftype, ino_ftype,
ino, lino);
- libxfs_dir2_sf_put_ftype(mp, sfep,
+ xfs_dir2_sf_put_ftype(mp, sfep,
ino_ftype);
dir_hash_update_ftype(hashtab,
(xfs_dir2_dataptr_t)(sfep - xfs_dir2_sf_firstentry(sfp)),
ASSERT(no_modify || bad_sfnamelen == 0);
next_sfep = (struct xfs_dir2_sf_entry *)((intptr_t)sfep +
(bad_sfnamelen
- ? libxfs_dir2_sf_entsize(mp, sfp, namelen)
- : libxfs_dir2_sf_entsize(mp, sfp, sfep->namelen)));
+ ? xfs_dir2_sf_entsize(mp, sfp, namelen)
+ : xfs_dir2_sf_entsize(mp, sfp, sfep->namelen)));
}
if (sfp->i8count != i8) {
*/
if (*ino_dirty && bytes_deleted > 0) {
ASSERT(!no_modify);
- libxfs_idata_realloc(ip, -bytes_deleted, XFS_DATA_FORK);
+ xfs_idata_realloc(ip, -bytes_deleted, XFS_DATA_FORK);
ip->i_d.di_size -= bytes_deleted;
}
* new define in ourselves.
*/
nres = no_modify ? 0 : XFS_REMOVE_SPACE_RES(mp);
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_remove,
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_remove,
nres, 0, 0, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
shortform_dir2_entry_check(mp, ino, ip, &dirty,
irec, ino_offset,
ASSERT(dirty == 0 || (dirty && !no_modify));
if (dirty) {
- libxfs_trans_log_inode(tp, ip,
+ xfs_trans_log_inode(tp, ip,
XFS_ILOG_CORE | XFS_ILOG_DDATA);
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(
_("error %d fixing shortform directory %llu\n"),
error,
(unsigned long long)ip->i_ino);
} else {
- libxfs_trans_cancel(tp);
+ xfs_trans_cancel(tp);
}
break;
do_warn(_("recreating root directory .. entry\n"));
nres = XFS_MKDIR_SPACE_RES(mp, 2);
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_mkdir,
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_mkdir,
nres, 0, 0, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
- error = -libxfs_dir_createname(tp, ip, &xfs_name_dotdot,
+ error = -xfs_dir_createname(tp, ip, &xfs_name_dotdot,
ip->i_ino, nres);
if (error)
do_error(
_("can't make \"..\" entry in root inode %" PRIu64 ", createname error %d\n"), ino, error);
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(
_("root inode \"..\" entry recreation failed (%d)\n"), error);
_("creating missing \".\" entry in dir ino %" PRIu64 "\n"), ino);
nres = XFS_MKDIR_SPACE_RES(mp, 1);
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_mkdir,
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_mkdir,
nres, 0, 0, &tp);
if (error)
res_failed(error);
- libxfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_ijoin(tp, ip, 0);
- error = -libxfs_dir_createname(tp, ip, &xfs_name_dot,
+ error = -xfs_dir_createname(tp, ip, &xfs_name_dot,
ip->i_ino, nres);
if (error)
do_error(
_("can't make \".\" entry in dir ino %" PRIu64 ", createname error %d\n"),
ino, error);
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_trans_commit(tp);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(
_("root inode \".\" entry recreation failed (%d)\n"), error);
int nres;
nres = no_modify ? 0 : 10;
- error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_remove, nres, 0, 0, &tp);
+ error = -xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, nres, 0, 0, &tp);
ASSERT(error == 0);
error = -libxfs_iget(mp, tp, ino, 0, &ip, &xfs_default_ifork_ops);
}
if (!dirty) {
- libxfs_trans_cancel(tp);
+ xfs_trans_cancel(tp);
} else {
- libxfs_trans_ijoin(tp, ip, 0);
- libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+ xfs_trans_ijoin(tp, ip, 0);
+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
/*
* no need to do a bmap finish since
* we're not allocating anything
*/
ASSERT(error == 0);
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
ASSERT(error == 0);
}
* the lock holder is either reading it from disk himself or
* completely overwriting it this behaviour is perfectly fine.
*/
- error = -libxfs_buf_get_map(mp->m_dev, map, nmaps,
+ error = -xfs_buf_get_map(mp->m_dev, map, nmaps,
LIBXFS_GETBUF_TRYLOCK, &bp);
if (error)
return;
pf_read_inode_dirs(args, bp);
libxfs_buf_set_priority(bp, libxfs_buf_priority(bp) +
CACHE_PREFETCH_PRIORITY);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return;
}
libxfs_buf_set_priority(bp, flag);
int rc;
int error;
- error = -libxfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, dbno),
+ error = -xfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, dbno),
XFS_FSB_TO_BB(mp, 1), LIBXFS_READBUF_SALVAGE, &bp,
&xfs_bmbt_buf_ops);
if (error)
*/
if (bp->b_error) {
bp->b_flags |= LIBXFS_B_UNCHECKED;
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return 0;
}
rc = (*func)(XFS_BUF_TO_BLOCK(bp), level - 1, isadir, args);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return rc;
}
return;
dsize = XFS_DFORK_DSIZE(dino, mp);
- pp = XFS_BMDR_PTR_ADDR(dib, 1, libxfs_bmdr_maxrecs(dsize, 0));
+ pp = XFS_BMDR_PTR_ADDR(dib, 1, xfs_bmdr_maxrecs(dsize, 0));
for (i = 0; i < numrecs; i++) {
dbno = get_unaligned_be64(&pp[i]);
if (be16_to_cpu(dino->di_magic) != XFS_DINODE_MAGIC)
continue;
- if (!libxfs_dinode_good_version(&mp->m_sb, dino->di_version))
+ if (!xfs_dinode_good_version(&mp->m_sb, dino->di_version))
continue;
if (be64_to_cpu(dino->di_size) <= XFS_DFORK_DSIZE(dino, mp))
if ((bplist[num - 1]->b_flags & LIBXFS_B_DISCONTIG)) {
libxfs_readbufr_map(mp->m_ddev_targp, bplist[num - 1], 0);
bplist[num - 1]->b_flags |= LIBXFS_B_UNCHECKED;
- libxfs_buf_relse(bplist[num - 1]);
+ xfs_buf_relse(bplist[num - 1]);
num--;
}
'I' : 'M',
bplist[i], (long long)XFS_BUF_ADDR(bplist[i]),
args->agno);
- libxfs_buf_relse(bplist[i]);
+ xfs_buf_relse(bplist[i]);
}
pthread_mutex_lock(&args->lock);
if (which != PF_SECONDARY) {
static inline int rmap_compare(const void *a, const void *b)
{
- return libxfs_rmap_compare(a, b);
+ return xfs_rmap_compare(a, b);
}
/*
goto err;
/* Add the AGFL blocks to the rmap list */
- error = -libxfs_trans_read_buf(
+ error = -xfs_trans_read_buf(
mp, NULL, mp->m_ddev_targp,
XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
XFS_FSS_TO_BB(mp, 1), 0, &agflbp, &xfs_agfl_buf_ops);
agfl_bno = xfs_buf_to_agfl_bno(agflbp);
b = agfl_bno + ag_rmap->ar_flcount;
while (*b != cpu_to_be32(NULLAGBLOCK) &&
- b - agfl_bno < libxfs_agfl_size(mp)) {
+ b - agfl_bno < xfs_agfl_size(mp)) {
xfs_agblock_t agbno;
agbno = be32_to_cpu(*b);
}
b++;
}
- libxfs_buf_relse(agflbp);
+ xfs_buf_relse(agflbp);
agflbp = NULL;
bitmap_free(&own_ag_bitmap);
while (rm_rec) {
struct xfs_owner_info oinfo = {};
- error = -libxfs_trans_alloc_rollable(mp, 16, &tp);
+ error = -xfs_trans_alloc_rollable(mp, 16, &tp);
if (error)
goto err_slab;
- error = -libxfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
+ error = -xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
if (error)
goto err_trans;
ASSERT(XFS_RMAP_NON_INODE_OWNER(rm_rec->rm_owner));
oinfo.oi_owner = rm_rec->rm_owner;
- error = -libxfs_rmap_alloc(tp, agbp, agno, rm_rec->rm_startblock,
+ error = -xfs_rmap_alloc(tp, agbp, agno, rm_rec->rm_startblock,
rm_rec->rm_blockcount, &oinfo);
if (error)
goto err_trans;
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
goto err_slab;
return 0;
err_trans:
- libxfs_trans_cancel(tp);
+ xfs_trans_cancel(tp);
err_slab:
free_slab_cursor(&rm_cur);
err:
if (agflbp)
- libxfs_buf_relse(agflbp);
+ xfs_buf_relse(agflbp);
if (own_ag_bitmap)
bitmap_free(&own_ag_bitmap);
return error;
int error;
/* Use the regular btree retrieval routine. */
- error = -libxfs_rmap_lookup_le(bt_cur, rm_rec->rm_startblock,
+ error = -xfs_rmap_lookup_le(bt_cur, rm_rec->rm_startblock,
rm_rec->rm_blockcount,
rm_rec->rm_owner, rm_rec->rm_offset,
rm_rec->rm_flags, have);
return error;
if (*have == 0)
return error;
- return -libxfs_rmap_get_rec(bt_cur, tmp, have);
+ return -xfs_rmap_get_rec(bt_cur, tmp, have);
}
/* Look for an rmap in the rmapbt that matches a given rmap. */
int *have)
{
/* Have to use our fancy version for overlapped */
- return -libxfs_rmap_lookup_le_range(bt_cur, rm_rec->rm_startblock,
+ return -xfs_rmap_lookup_le_range(bt_cur, rm_rec->rm_startblock,
rm_rec->rm_owner, rm_rec->rm_offset,
rm_rec->rm_flags, tmp, have);
}
if (error)
return error;
- error = -libxfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
+ error = -xfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
if (error)
goto err;
/* Leave the per-ag data "uninitialized" since we rewrite it later */
- pag = libxfs_perag_get(mp, agno);
+ pag = xfs_perag_get(mp, agno);
pag->pagf_init = 0;
- libxfs_perag_put(pag);
+ xfs_perag_put(pag);
- bt_cur = libxfs_rmapbt_init_cursor(mp, NULL, agbp, agno);
+ bt_cur = xfs_rmapbt_init_cursor(mp, NULL, agbp, agno);
if (!bt_cur) {
error = -ENOMEM;
goto err;
err:
if (bt_cur)
- libxfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
+ xfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
if (agbp)
- libxfs_buf_relse(agbp);
+ xfs_buf_relse(agbp);
free_slab_cursor(&rm_cur);
return 0;
}
tmp = *kp1;
tmp.rm_flags &= ~XFS_RMAP_REC_FLAGS;
- oa = libxfs_rmap_irec_offset_pack(&tmp);
+ oa = xfs_rmap_irec_offset_pack(&tmp);
tmp = *kp2;
tmp.rm_flags &= ~XFS_RMAP_REC_FLAGS;
- ob = libxfs_rmap_irec_offset_pack(&tmp);
+ ob = xfs_rmap_irec_offset_pack(&tmp);
d = (int64_t)kp1->rm_startblock - kp2->rm_startblock;
if (d)
dino->di_flags2 |= cpu_to_be64(XFS_DIFLAG2_REFLINK);
else
dino->di_flags2 &= cpu_to_be64(~XFS_DIFLAG2_REFLINK);
- libxfs_dinode_calc_crc(mp, dino);
+ xfs_dinode_calc_crc(mp, dino);
libxfs_buf_mark_dirty(buf);
- libxfs_buf_relse(buf);
+ xfs_buf_relse(buf);
return 0;
}
if (error)
return error;
- error = -libxfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
+ error = -xfs_alloc_read_agf(mp, NULL, agno, 0, &agbp);
if (error)
goto err;
/* Leave the per-ag data "uninitialized" since we rewrite it later */
- pag = libxfs_perag_get(mp, agno);
+ pag = xfs_perag_get(mp, agno);
pag->pagf_init = 0;
- libxfs_perag_put(pag);
+ xfs_perag_put(pag);
- bt_cur = libxfs_refcountbt_init_cursor(mp, NULL, agbp, agno);
+ bt_cur = xfs_refcountbt_init_cursor(mp, NULL, agbp, agno);
if (!bt_cur) {
error = -ENOMEM;
goto err;
rl_rec = pop_slab_cursor(rl_cur);
while (rl_rec) {
/* Look for a refcount record in the btree */
- error = -libxfs_refcount_lookup_le(bt_cur,
+ error = -xfs_refcount_lookup_le(bt_cur,
rl_rec->rc_startblock, &have);
if (error)
goto err;
goto next_loop;
}
- error = -libxfs_refcount_get_rec(bt_cur, &tmp, &i);
+ error = -xfs_refcount_get_rec(bt_cur, &tmp, &i);
if (error)
goto err;
if (!i) {
err:
if (bt_cur)
- libxfs_btree_del_cursor(bt_cur, error ? XFS_BTREE_ERROR :
+ xfs_btree_del_cursor(bt_cur, error ? XFS_BTREE_ERROR :
XFS_BTREE_NOERROR);
if (agbp)
- libxfs_buf_relse(agbp);
+ xfs_buf_relse(agbp);
free_slab_cursor(&rl_cur);
return 0;
}
args.mp = mp;
args.agno = agno;
args.alignment = 1;
- args.pag = libxfs_perag_get(mp, agno);
- error = -libxfs_trans_alloc_rollable(mp, 0, &tp);
+ args.pag = xfs_perag_get(mp, agno);
+ error = -xfs_trans_alloc_rollable(mp, 0, &tp);
if (error)
do_error(_("failed to fix AGFL on AG %d, error %d\n"),
agno, error);
flags = XFS_ALLOC_FLAG_NOSHRINK;
if (skip_rmapbt)
flags |= XFS_ALLOC_FLAG_NORMAP;
- error = -libxfs_alloc_fix_freelist(&args, flags);
- libxfs_perag_put(args.pag);
+ error = -xfs_alloc_fix_freelist(&args, flags);
+ xfs_perag_put(args.pag);
if (error) {
do_error(_("failed to fix AGFL on AG %d, error %d\n"),
agno, error);
}
- error = -libxfs_trans_commit(tp);
+ error = -xfs_trans_commit(tp);
if (error)
do_error(_("%s: commit failed, error %d\n"), __func__, error);
}
#include "err_protos.h"
#include "rt.h"
-#define xfs_highbit64 libxfs_highbit64 /* for XFS_RTBLOCKLOG macro */
-
void
rtinit(xfs_mount_t *mp)
{
error = 1;
continue;
}
- error = -libxfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
+ error = -xfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
XFS_FSB_TO_BB(mp, 1), 0, NULL, &bp);
if (error) {
do_warn(_("can't read block %d for rtbitmap inode\n"),
prevbit = 0;
}
}
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
if (extno == mp->m_sb.sb_rextents)
break;
}
error++;
continue;
}
- error = -libxfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
+ error = -xfs_buf_read(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),
XFS_FSB_TO_BB(mp, 1), 0, NULL, &bp);
if (error) {
do_warn(_("can't read block %d for rtsummary inode\n"),
bytes = bp->b_un.b_addr;
memmove((char *)sumfile + sumbno * mp->m_sb.sb_blocksize, bytes,
mp->m_sb.sb_blocksize);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
}
#endif
*/
for (i = 0; !done && i < bsize; i += BBSIZE) {
c_bufsb = (char *)sb + i;
- libxfs_sb_from_disk(&bufsb, (xfs_dsb_t *)c_bufsb);
+ xfs_sb_from_disk(&bufsb, (xfs_dsb_t *)c_bufsb);
if (verify_sb(c_bufsb, &bufsb, 0) != XR_OK)
continue;
/* sector size in range - CRC check time */
if (xfs_sb_version_hascrc(sb) &&
- !libxfs_verify_cksum(sb_buf, sb->sb_sectsize, XFS_SB_CRC_OFF))
+ !xfs_verify_cksum(sb_buf, sb->sb_sectsize, XFS_SB_CRC_OFF))
return XR_BAD_CRC;
/* check to ensure blocksize and blocklog are legal */
return(XR_BAD_RT_GEO_DATA);
if (sb->sb_rextslog !=
- libxfs_highbit32((unsigned int)sb->sb_rextents))
+ xfs_highbit32((unsigned int)sb->sb_rextents))
return(XR_BAD_RT_GEO_DATA);
if (sb->sb_rbmblocks != (xfs_extlen_t) howmany(sb->sb_rextents,
do_error(_("couldn't seek to offset 0 in filesystem\n"));
}
- libxfs_sb_to_disk(buf, sbp);
+ xfs_sb_to_disk(buf, sbp);
if (xfs_sb_version_hascrc(sbp))
xfs_update_cksum((char *)buf, size, XFS_SB_CRC_OFF);
off, size, agno, rval);
do_error("%s\n", strerror(error));
}
- libxfs_sb_from_disk(sbp, buf);
+ xfs_sb_from_disk(sbp, buf);
rval = verify_sb((char *)buf, sbp, agno == 0);
free(buf);
{
int error;
- error = -libxfs_buf_read(target, blkno, numblks,
+ error = -xfs_buf_read(target, blkno, numblks,
LIBXFS_READBUF_SALVAGE, bpp, ops);
if (error != EIO)
return error;
* be full of zeroes) and make it look like we read the data from the
* disk but it failed verification.
*/
- error = -libxfs_buf_get(target, blkno, numblks, bpp);
+ error = -xfs_buf_get(target, blkno, numblks, bpp);
if (error)
return error;
(*func)(XFS_BUF_TO_BLOCK(bp), nlevels - 1, root, agno, suspect,
isroot, magic, priv, ops);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
/*
if ((dirty || badcrc) && !no_modify) {
libxfs_buf_mark_dirty(bp);
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
}
else
- libxfs_buf_relse(bp);
+ xfs_buf_relse(bp);
return(err);
}
key.rm_startblock = b;
key.rm_blockcount = len;
key.rm_owner = owner;
- if (libxfs_rmap_irec_offset_unpack(offset, &key)) {
+ if (xfs_rmap_irec_offset_unpack(offset, &key)) {
/* Look for impossible flags. */
do_warn(
_("invalid flags in record %u of %s btree block %u/%u\n"),
key.rm_flags = 0;
key.rm_startblock = be32_to_cpu(kp->rm_startblock);
key.rm_owner = be64_to_cpu(kp->rm_owner);
- if (libxfs_rmap_irec_offset_unpack(be64_to_cpu(kp->rm_offset),
+ if (xfs_rmap_irec_offset_unpack(be64_to_cpu(kp->rm_offset),
&key)) {
/* Look for impossible flags. */
do_warn(
be32_to_cpu(kp->rm_startblock);
rmap_priv->high_key.rm_owner =
be64_to_cpu(kp->rm_owner);
- if (libxfs_rmap_irec_offset_unpack(be64_to_cpu(kp->rm_offset),
+ if (xfs_rmap_irec_offset_unpack(be64_to_cpu(kp->rm_offset),
&rmap_priv->high_key)) {
/* Look for impossible flags. */
do_warn(
if (no_modify) {
/* agf values not fixed in verify_set_agf, so recheck */
- if (be32_to_cpu(agf->agf_flfirst) >= libxfs_agfl_size(mp) ||
- be32_to_cpu(agf->agf_fllast) >= libxfs_agfl_size(mp)) {
+ if (be32_to_cpu(agf->agf_flfirst) >= xfs_agfl_size(mp) ||
+ be32_to_cpu(agf->agf_fllast) >= xfs_agfl_size(mp)) {
do_warn(_("agf %d freelist blocks bad, skipping "
"freelist scan\n"), agno);
return;
state.count = 0;
state.agno = agno;
- libxfs_agfl_walk(mp, agf, agflbuf, scan_agfl, &state);
+ xfs_agfl_walk(mp, agf, agflbuf, scan_agfl, &state);
if (state.count != be32_to_cpu(agf->agf_flcount)) {
do_warn(_("freeblk count %d != flcount %d in ag %d\n"),
state.count, be32_to_cpu(agf->agf_flcount),
agcnts->fdblocks += state.count;
- libxfs_buf_relse(agflbuf);
+ xfs_buf_relse(agflbuf);
}
static void
objname = _("root superblock");
goto out_free_sb;
}
- libxfs_sb_from_disk(sb, sbbuf->b_addr);
+ xfs_sb_from_disk(sb, sbbuf->b_addr);
error = salvage_buffer(mp->m_dev,
XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
if (agi_dirty && !no_modify) {
libxfs_buf_mark_dirty(agibuf);
- libxfs_buf_relse(agibuf);
+ xfs_buf_relse(agibuf);
}
else
- libxfs_buf_relse(agibuf);
+ xfs_buf_relse(agibuf);
if (agf_dirty && !no_modify) {
libxfs_buf_mark_dirty(agfbuf);
- libxfs_buf_relse(agfbuf);
+ xfs_buf_relse(agfbuf);
}
else
- libxfs_buf_relse(agfbuf);
+ xfs_buf_relse(agfbuf);
if (sb_dirty && !no_modify) {
if (agno == 0)
memcpy(&mp->m_sb, sb, sizeof(xfs_sb_t));
- libxfs_sb_to_disk(sbbuf->b_addr, sb);
+ xfs_sb_to_disk(sbbuf->b_addr, sb);
libxfs_buf_mark_dirty(sbbuf);
- libxfs_buf_relse(sbbuf);
+ xfs_buf_relse(sbbuf);
} else
- libxfs_buf_relse(sbbuf);
+ xfs_buf_relse(sbbuf);
free(sb);
PROG_RPT_INC(prog_rpt_done[agno], 1);
return;
out_free_agibuf:
- libxfs_buf_relse(agibuf);
+ xfs_buf_relse(agibuf);
out_free_agfbuf:
- libxfs_buf_relse(agfbuf);
+ xfs_buf_relse(agfbuf);
out_free_sbbuf:
- libxfs_buf_relse(sbbuf);
+ xfs_buf_relse(sbbuf);
out_free_sb:
free(sb);
if (!S_ISDIR(VFS_I(ip)->i_mode))
goto out_rele;
- error = -libxfs_dir_lookup(NULL, ip, &xfs_name_dotdot, &ino, NULL);
+ error = -xfs_dir_lookup(NULL, ip, &xfs_name_dotdot, &ino, NULL);
if (error)
goto out_rele;
/* Try reading secondary supers to see if we find a good sb_unit. */
for (agno = 1; agno < mp->m_sb.sb_agcount; agno++) {
- error = -libxfs_sb_read_secondary(mp, NULL, agno, &bp);
+ error = -xfs_sb_read_secondary(mp, NULL, agno, &bp);
if (error)
continue;
- libxfs_sb_from_disk(&sb, bp->b_addr);
- libxfs_buf_relse(bp);
+ xfs_sb_from_disk(&sb, bp->b_addr);
+ xfs_buf_relse(bp);
- calc_rootino = libxfs_ialloc_calc_rootino(mp, sb.sb_unit);
+ calc_rootino = xfs_ialloc_calc_rootino(mp, sb.sb_unit);
if (calc_rootino == mp->m_sb.sb_rootino)
break;
}
for (sunit_guess = 1;
sunit_guess <= XFS_AG_MAX_BLOCKS(mp->m_sb.sb_blocklog);
sunit_guess *= 2) {
- calc_rootino = libxfs_ialloc_calc_rootino(mp, sunit_guess);
+ calc_rootino = xfs_ialloc_calc_rootino(mp, sunit_guess);
if (calc_rootino == mp->m_sb.sb_rootino)
break;
}
{
xfs_ino_t rootino;
- rootino = libxfs_ialloc_calc_rootino(mp, mp->m_sb.sb_unit);
+ rootino = xfs_ialloc_calc_rootino(mp, mp->m_sb.sb_unit);
/*
* If the root inode isn't where we think it is, check its plausibility
glob_agcount = mp->m_sb.sb_agcount;
chunks_pblock = mp->m_sb.sb_inopblock / XFS_INODES_PER_CHUNK;
- max_symlink_blocks = libxfs_symlink_blocks(mp, XFS_SYMLINK_MAXLEN);
+ max_symlink_blocks = xfs_symlink_blocks(mp, XFS_SYMLINK_MAXLEN);
/*
* Automatic striding for high agcount filesystems.
}
libxfs_buf_mark_dirty(sbp);
- libxfs_buf_relse(sbp);
+ xfs_buf_relse(sbp);
/*
* Done. Flush all cached buffers and inodes first to ensure all
#!/bin/bash
# SPDX-License-Identifier: GPL-2.0
-# Find libxfs API violations -- calls to functions defined in libxfs/*.c that
-# don't use the libxfs wrappers; or failing to negate the integer return
-# values.
-
-# NOTE: This script doesn't look for API violations in function parameters.
+# Find places that fail to negate the integer return values.
tool_dirs="copy db estimate fsck fsr growfs io logprint mdrestore mkfs quota repair rtcp scrub"
-# Calls to xfs_* functions in libxfs/*.c without the libxfs_ prefix
-find_possible_api_calls() {
- grep -rn '[-[:space:],(]xfs_[a-z_]*(' $tool_dirs | sed -e 's/^.*\(xfs_[a-z_]*\)(.*$/\1/g' | sort | uniq
-}
-
-check_if_api_calls() {
- while read f; do grep "^$f(" libxfs/*.c; done | sed -e 's/^.*:xfs_/xfs_/g' -e 's/.$//g'
-}
-
-# Generate a grep search expression for troublesome API call sites.
-# " foo(", ",foo(", "-foo(", and "(foo(" are examples.
-grep_pattern() {
- sed -e 's/^/[[:space:],-\\(]/g' -e 's/$/(/g'
-}
-
-find_libxfs_violations() {
- grep -r -n -f <(find_possible_api_calls | check_if_api_calls | grep_pattern) $tool_dirs
-}
-
# libxfs calls without negated error codes
find_errcode_violations() {
- grep -r -n 'err.* = libxfs' $tool_dirs
-}
-
-# Find xfs_* calls that are in the libxfs definition list
-find_possible_libxfs_api_calls() {
- grep '#define[[:space:]]*xfs' libxfs/libxfs_api_defs.h | awk '{print $2}'
-}
-
-find_libxfs_api_violations() {
- grep -r -n -f <(find_possible_libxfs_api_calls | grep_pattern) $tool_dirs
+ grep -r -n 'err.* = xfs_' $tool_dirs
}
-(find_libxfs_violations ; find_errcode_violations ; find_libxfs_api_violations) | sort -g -t ':' -k 2 | sort -g -t ':' -k 1 | uniq
+find_errcode_violations | sort -g -t ':' -k 2 | sort -g -t ':' -k 1 | uniq
projects / users / hch / xfsprogs.git / commitdiff