extern int libxfs_alloc_file_space (struct xfs_inode *, xfs_off_t,
xfs_off_t, int, int);
-#define libxfs_bmap_finish xfs_defer_finish
-#define libxfs_bmap_cancel xfs_defer_cancel
-#define xfs_bmap_free_t struct xfs_defer_ops
-extern void libxfs_fs_repair_cmn_err(int, struct xfs_mount *, char *, ...);
+extern void libxfs_fs_repair_cmn_err(int, struct xfs_mount *, char *, ...);
extern void libxfs_fs_cmn_err(int, struct xfs_mount *, char *, ...);
/* XXX: this is messy and needs fixing */
xfs_btree_cur_zone = kmem_zone_init(
sizeof(xfs_btree_cur_t), "xfs_btree_cur");
xfs_bmap_free_item_zone = kmem_zone_init(
- sizeof(struct xfs_bmap_free_item), "xfs_bmap_free_item");
+ sizeof(struct xfs_extent_free_item),
+ "xfs_bmap_free_item");
xfs_log_item_desc_zone = kmem_zone_init(
sizeof(struct xfs_log_item_desc), "xfs_log_item_desc");
xfs_dir_startup();
#define xfs_rtfree_extent libxfs_rtfree_extent
#define xfs_zero_extent libxfs_zero_extent
+#define xfs_defer_init libxfs_defer_init
+#define xfs_defer_finish libxfs_defer_finish
+#define xfs_defer_cancel libxfs_defer_cancel
+
#define xfs_da_brelse libxfs_da_brelse
#define xfs_da_hashname libxfs_da_hashname
#define xfs_da_shrink_inode libxfs_da_shrink_inode
xfs_filblks_t allocated_fsb;
xfs_filblks_t allocatesize_fsb;
xfs_fsblock_t firstfsb;
- xfs_bmap_free_t free_list;
+ struct xfs_defer_ops free_list;
xfs_bmbt_irec_t *imapp;
xfs_bmbt_irec_t imaps[1];
int reccount;
}
xfs_trans_ijoin(tp, ip, 0);
- xfs_bmap_init(&free_list, &firstfsb);
+ xfs_defer_init(&free_list, &firstfsb);
error = xfs_bmapi_write(tp, ip, startoffset_fsb, allocatesize_fsb,
xfs_bmapi_flags, &firstfsb, 0, imapp,
&reccount, &free_list);
goto error0;
/* complete the transaction */
- error = xfs_bmap_finish(&tp, &free_list, ip);
+ error = xfs_defer_finish(&tp, &free_list, ip);
if (error)
goto error0;
return error;
error0: /* Cancel bmap, cancel trans */
- xfs_bmap_cancel(&free_list);
+ xfs_defer_cancel(&free_list);
xfs_trans_cancel(tp);
return error;
}
{
struct xfs_mount *mp = dp->i_mount;
struct xfs_da_args args;
- struct xfs_bmap_free flist;
+ struct xfs_defer_ops flist;
struct xfs_trans_res tres;
xfs_fsblock_t firstblock;
int rsvd = (flags & ATTR_ROOT) != 0;
* It won't fit in the shortform, transform to a leaf block.
* GROT: another possible req'mt for a double-split btree op.
*/
- xfs_bmap_init(args.flist, args.firstblock);
+ xfs_defer_init(args.flist, args.firstblock);
error = xfs_attr_shortform_to_leaf(&args);
if (!error)
- error = xfs_bmap_finish(&args.trans, args.flist, dp);
+ error = xfs_defer_finish(&args.trans, args.flist, dp);
if (error) {
args.trans = NULL;
- xfs_bmap_cancel(&flist);
+ xfs_defer_cancel(&flist);
goto out;
}
{
struct xfs_mount *mp = dp->i_mount;
struct xfs_da_args args;
- struct xfs_bmap_free flist;
+ struct xfs_defer_ops flist;
xfs_fsblock_t firstblock;
int error;
* Commit that transaction so that the node_addname() call
* can manage its own transactions.
*/
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_node(args);
if (!error)
- error = xfs_bmap_finish(&args->trans, args->flist, dp);
+ error = xfs_defer_finish(&args->trans, args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
return error;
}
* If the result is small enough, shrink it all into the inode.
*/
if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
/* bp is gone due to xfs_da_shrink_inode */
if (!error)
- error = xfs_bmap_finish(&args->trans,
+ error = xfs_defer_finish(&args->trans,
args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
return error;
}
}
* If the result is small enough, shrink it all into the inode.
*/
if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
/* bp is gone due to xfs_da_shrink_inode */
if (!error)
- error = xfs_bmap_finish(&args->trans, args->flist, dp);
+ error = xfs_defer_finish(&args->trans, args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
return error;
}
}
*/
xfs_da_state_free(state);
state = NULL;
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_node(args);
if (!error)
- error = xfs_bmap_finish(&args->trans,
+ error = xfs_defer_finish(&args->trans,
args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
goto out;
}
* in the index/blkno/rmtblkno/rmtblkcnt fields and
* in the index2/blkno2/rmtblkno2/rmtblkcnt2 fields.
*/
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_da3_split(state);
if (!error)
- error = xfs_bmap_finish(&args->trans, args->flist, dp);
+ error = xfs_defer_finish(&args->trans, args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
goto out;
}
} else {
* Check to see if the tree needs to be collapsed.
*/
if (retval && (state->path.active > 1)) {
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_da3_join(state);
if (!error)
- error = xfs_bmap_finish(&args->trans,
+ error = xfs_defer_finish(&args->trans,
args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
goto out;
}
}
* Check to see if the tree needs to be collapsed.
*/
if (retval && (state->path.active > 1)) {
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_da3_join(state);
if (!error)
- error = xfs_bmap_finish(&args->trans, args->flist, dp);
+ error = xfs_defer_finish(&args->trans, args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
goto out;
}
/*
goto out;
if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
/* bp is gone due to xfs_da_shrink_inode */
if (!error)
- error = xfs_bmap_finish(&args->trans,
+ error = xfs_defer_finish(&args->trans,
args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
goto out;
}
} else
* extent and then crash then the block may not contain the
* correct metadata after log recovery occurs.
*/
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
nmap = 1;
error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno,
blkcnt, XFS_BMAPI_ATTRFORK, args->firstblock,
args->total, &map, &nmap, args->flist);
if (!error)
- error = xfs_bmap_finish(&args->trans, args->flist, dp);
+ error = xfs_defer_finish(&args->trans, args->flist, dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
return error;
}
ASSERT(blkcnt > 0);
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
nmap = 1;
error = xfs_bmapi_read(dp, (xfs_fileoff_t)lblkno,
blkcnt, &map, &nmap,
blkcnt = args->rmtblkcnt;
done = 0;
while (!done) {
- xfs_bmap_init(args->flist, args->firstblock);
+ xfs_defer_init(args->flist, args->firstblock);
error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt,
XFS_BMAPI_ATTRFORK, 1, args->firstblock,
args->flist, &done);
if (!error)
- error = xfs_bmap_finish(&args->trans, args->flist,
+ error = xfs_defer_finish(&args->trans, args->flist,
args->dp);
if (error) {
args->trans = NULL;
- xfs_bmap_cancel(args->flist);
+ xfs_defer_cancel(args->flist);
return error;
}
void
xfs_bmap_add_free(
struct xfs_mount *mp, /* mount point structure */
- struct xfs_bmap_free *flist, /* list of extents */
+ struct xfs_defer_ops *flist, /* list of extents */
xfs_fsblock_t bno, /* fs block number of extent */
xfs_filblks_t len) /* length of extent */
{
- struct xfs_bmap_free_item *new; /* new element */
+ struct xfs_extent_free_item *new; /* new element */
#ifdef DEBUG
xfs_agnumber_t agno;
xfs_agblock_t agbno;
#endif
ASSERT(xfs_bmap_free_item_zone != NULL);
new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP);
- new->xbfi_startblock = bno;
- new->xbfi_blockcount = (xfs_extlen_t)len;
- xfs_defer_add(flist, XFS_DEFER_OPS_TYPE_FREE, &new->xbfi_list);
+ new->xefi_startblock = bno;
+ new->xefi_blockcount = (xfs_extlen_t)len;
+ xfs_defer_add(flist, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list);
}
/*
xfs_trans_t *tp, /* transaction pointer */
xfs_inode_t *ip, /* incore inode pointer */
xfs_fsblock_t *firstblock, /* first-block-allocated */
- xfs_bmap_free_t *flist, /* blocks freed in xaction */
+ struct xfs_defer_ops *flist, /* blocks freed in xaction */
xfs_btree_cur_t **curp, /* cursor returned to caller */
int wasdel, /* converting a delayed alloc */
int *logflagsp, /* inode logging flags */
xfs_trans_t *tp, /* transaction pointer */
xfs_inode_t *ip, /* incore inode pointer */
xfs_fsblock_t *firstblock, /* first block allocated */
- xfs_bmap_free_t *flist, /* blocks to free at commit */
+ struct xfs_defer_ops *flist, /* blocks to free at commit */
int *flags) /* inode logging flags */
{
xfs_btree_cur_t *cur; /* btree cursor */
xfs_trans_t *tp, /* transaction pointer */
xfs_inode_t *ip, /* incore inode pointer */
xfs_fsblock_t *firstblock, /* first block allocated */
- xfs_bmap_free_t *flist, /* blocks to free at commit */
+ struct xfs_defer_ops *flist, /* blocks to free at commit */
int *flags) /* inode logging flags */
{
xfs_btree_cur_t *cur; /* bmap btree cursor */
xfs_trans_t *tp, /* transaction pointer */
xfs_inode_t *ip, /* incore inode pointer */
xfs_fsblock_t *firstblock, /* first block allocated */
- xfs_bmap_free_t *flist, /* blocks to free at commit */
+ struct xfs_defer_ops *flist, /* blocks to free at commit */
int *flags) /* inode logging flags */
{
xfs_da_args_t dargs; /* args for dir/attr code */
int rsvd) /* xact may use reserved blks */
{
xfs_fsblock_t firstblock; /* 1st block/ag allocated */
- xfs_bmap_free_t flist; /* freed extent records */
+ struct xfs_defer_ops flist; /* freed extent records */
xfs_mount_t *mp; /* mount structure */
xfs_trans_t *tp; /* transaction pointer */
int blks; /* space reservation */
ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
ip->i_afp->if_flags = XFS_IFEXTENTS;
logflags = 0;
- xfs_bmap_init(&flist, &firstblock);
+ xfs_defer_init(&flist, &firstblock);
switch (ip->i_d.di_format) {
case XFS_DINODE_FMT_LOCAL:
error = xfs_bmap_add_attrfork_local(tp, ip, &firstblock, &flist,
xfs_log_sb(tp);
}
- error = xfs_bmap_finish(&tp, &flist, NULL);
+ error = xfs_defer_finish(&tp, &flist, NULL);
if (error)
goto bmap_cancel;
error = xfs_trans_commit(tp);
return error;
bmap_cancel:
- xfs_bmap_cancel(&flist);
+ xfs_defer_cancel(&flist);
trans_cancel:
xfs_trans_cancel(tp);
xfs_iunlock(ip, XFS_ILOCK_EXCL);
xfs_btree_cur_t **curp, /* if *curp is null, not a btree */
xfs_bmbt_irec_t *new, /* new data to add to file extents */
xfs_fsblock_t *first, /* pointer to firstblock variable */
- xfs_bmap_free_t *flist, /* list of extents to be freed */
+ struct xfs_defer_ops *flist, /* list of extents to be freed */
int *logflagsp) /* inode logging flags */
{
xfs_btree_cur_t *cur; /* btree cursor */
xfs_extlen_t total, /* total blocks needed */
struct xfs_bmbt_irec *mval, /* output: map values */
int *nmap, /* i/o: mval size/count */
- struct xfs_bmap_free *flist) /* i/o: list extents to free */
+ struct xfs_defer_ops *flist) /* i/o: list extents to free */
{
struct xfs_mount *mp = ip->i_mount;
struct xfs_ifork *ifp;
xfs_inode_t *ip, /* incore inode pointer */
xfs_trans_t *tp, /* current transaction pointer */
xfs_extnum_t *idx, /* extent number to update/delete */
- xfs_bmap_free_t *flist, /* list of extents to be freed */
+ struct xfs_defer_ops *flist, /* list of extents to be freed */
xfs_btree_cur_t *cur, /* if null, not a btree */
xfs_bmbt_irec_t *del, /* data to remove from extents */
int *logflagsp, /* inode logging flags */
xfs_extnum_t nexts, /* number of extents max */
xfs_fsblock_t *firstblock, /* first allocated block
controls a.g. for allocs */
- xfs_bmap_free_t *flist, /* i/o: list extents to free */
+ struct xfs_defer_ops *flist, /* i/o: list extents to free */
int *done) /* set if not done yet */
{
xfs_btree_cur_t *cur; /* bmap btree cursor */
int *done,
xfs_fileoff_t stop_fsb,
xfs_fsblock_t *firstblock,
- struct xfs_bmap_free *flist,
+ struct xfs_defer_ops *flist,
enum shift_direction direction,
int num_exts)
{
struct xfs_inode *ip,
xfs_fileoff_t split_fsb,
xfs_fsblock_t *firstfsb,
- struct xfs_bmap_free *free_list)
+ struct xfs_defer_ops *free_list)
{
int whichfork = XFS_DATA_FORK;
struct xfs_btree_cur *cur = NULL;
{
struct xfs_mount *mp = ip->i_mount;
struct xfs_trans *tp;
- struct xfs_bmap_free free_list;
+ struct xfs_defer_ops free_list;
xfs_fsblock_t firstfsb;
int error;
xfs_ilock(ip, XFS_ILOCK_EXCL);
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
- xfs_bmap_init(&free_list, &firstfsb);
+ xfs_defer_init(&free_list, &firstfsb);
error = xfs_bmap_split_extent_at(tp, ip, split_fsb,
&firstfsb, &free_list);
if (error)
goto out;
- error = xfs_bmap_finish(&tp, &free_list, NULL);
+ error = xfs_defer_finish(&tp, &free_list, NULL);
if (error)
goto out;
return xfs_trans_commit(tp);
out:
- xfs_bmap_cancel(&free_list);
+ xfs_defer_cancel(&free_list);
xfs_trans_cancel(tp);
return error;
}
*/
struct xfs_bmalloca {
xfs_fsblock_t *firstblock; /* i/o first block allocated */
- struct xfs_bmap_free *flist; /* bmap freelist */
+ struct xfs_defer_ops *flist; /* bmap freelist */
struct xfs_trans *tp; /* transaction pointer */
struct xfs_inode *ip; /* incore inode pointer */
struct xfs_bmbt_irec prev; /* extent before the new one */
* List of extents to be free "later".
* The list is kept sorted on xbf_startblock.
*/
-struct xfs_bmap_free_item
+struct xfs_extent_free_item
{
- xfs_fsblock_t xbfi_startblock;/* starting fs block number */
- xfs_extlen_t xbfi_blockcount;/* number of blocks in extent */
- struct list_head xbfi_list;
+ xfs_fsblock_t xefi_startblock;/* starting fs block number */
+ xfs_extlen_t xefi_blockcount;/* number of blocks in extent */
+ struct list_head xefi_list;
};
#define XFS_BMAP_MAX_NMAP 4
int xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);
void xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork);
-void xfs_bmap_add_free(struct xfs_mount *mp, struct xfs_bmap_free *flist,
+void xfs_bmap_add_free(struct xfs_mount *mp, struct xfs_defer_ops *flist,
xfs_fsblock_t bno, xfs_filblks_t len);
void xfs_bmap_compute_maxlevels(struct xfs_mount *mp, int whichfork);
int xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip,
xfs_fileoff_t bno, xfs_filblks_t len, int flags,
xfs_fsblock_t *firstblock, xfs_extlen_t total,
struct xfs_bmbt_irec *mval, int *nmap,
- struct xfs_bmap_free *flist);
+ struct xfs_defer_ops *flist);
int xfs_bunmapi(struct xfs_trans *tp, struct xfs_inode *ip,
xfs_fileoff_t bno, xfs_filblks_t len, int flags,
xfs_extnum_t nexts, xfs_fsblock_t *firstblock,
- struct xfs_bmap_free *flist, int *done);
+ struct xfs_defer_ops *flist, int *done);
int xfs_check_nostate_extents(struct xfs_ifork *ifp, xfs_extnum_t idx,
xfs_extnum_t num);
uint xfs_default_attroffset(struct xfs_inode *ip);
int xfs_bmap_shift_extents(struct xfs_trans *tp, struct xfs_inode *ip,
xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb,
int *done, xfs_fileoff_t stop_fsb, xfs_fsblock_t *firstblock,
- struct xfs_bmap_free *flist, enum shift_direction direction,
+ struct xfs_defer_ops *flist, enum shift_direction direction,
int num_exts);
int xfs_bmap_split_extent(struct xfs_inode *ip, xfs_fileoff_t split_offset);
#define __XFS_BTREE_H__
struct xfs_buf;
-struct xfs_bmap_free;
+struct xfs_defer_ops;
struct xfs_inode;
struct xfs_mount;
struct xfs_trans;
union {
struct { /* needed for BNO, CNT, INO */
struct xfs_buf *agbp; /* agf/agi buffer pointer */
+ struct xfs_defer_ops *flist; /* deferred updates */
xfs_agnumber_t agno; /* ag number */
} a;
struct { /* needed for BMAP */
struct xfs_inode *ip; /* pointer to our inode */
- struct xfs_bmap_free *flist; /* list to free after */
+ struct xfs_defer_ops *flist; /* deferred updates */
xfs_fsblock_t firstblock; /* 1st blk allocated */
int allocated; /* count of alloced */
short forksize; /* fork's inode space */
#ifndef __XFS_DA_BTREE_H__
#define __XFS_DA_BTREE_H__
-struct xfs_bmap_free;
+struct xfs_defer_ops;
struct xfs_inode;
struct xfs_trans;
struct zone;
xfs_ino_t inumber; /* input/output inode number */
struct xfs_inode *dp; /* directory inode to manipulate */
xfs_fsblock_t *firstblock; /* ptr to firstblock for bmap calls */
- struct xfs_bmap_free *flist; /* ptr to freelist for bmap_finish */
+ struct xfs_defer_ops *flist; /* ptr to freelist for bmap_finish */
struct xfs_trans *trans; /* current trans (changes over time) */
xfs_extlen_t total; /* total blocks needed, for 1st bmap */
int whichfork; /* data or attribute fork */
void xfs_defer_init_op_type(const struct xfs_defer_op_type *type);
-/* XXX: compatibility shims, will go away in the next patch */
-#define xfs_bmap_finish xfs_defer_finish
-#define xfs_bmap_cancel xfs_defer_cancel
-#define xfs_bmap_init xfs_defer_init
-#define xfs_bmap_free xfs_defer_ops
-typedef struct xfs_defer_ops xfs_bmap_free_t;
-
#endif /* __XFS_DEFER_H__ */
struct xfs_name *name,
xfs_ino_t inum, /* new entry inode number */
xfs_fsblock_t *first, /* bmap's firstblock */
- xfs_bmap_free_t *flist, /* bmap's freeblock list */
+ struct xfs_defer_ops *flist, /* bmap's freeblock list */
xfs_extlen_t total) /* bmap's total block count */
{
struct xfs_da_args *args;
struct xfs_name *name,
xfs_ino_t ino,
xfs_fsblock_t *first, /* bmap's firstblock */
- xfs_bmap_free_t *flist, /* bmap's freeblock list */
+ struct xfs_defer_ops *flist, /* bmap's freeblock list */
xfs_extlen_t total) /* bmap's total block count */
{
struct xfs_da_args *args;
struct xfs_name *name, /* name of entry to replace */
xfs_ino_t inum, /* new inode number */
xfs_fsblock_t *first, /* bmap's firstblock */
- xfs_bmap_free_t *flist, /* bmap's freeblock list */
+ struct xfs_defer_ops *flist, /* bmap's freeblock list */
xfs_extlen_t total) /* bmap's total block count */
{
struct xfs_da_args *args;
#ifndef __XFS_DIR2_H__
#define __XFS_DIR2_H__
-struct xfs_bmap_free;
+struct xfs_defer_ops;
struct xfs_da_args;
struct xfs_inode;
struct xfs_mount;
extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t inum,
xfs_fsblock_t *first,
- struct xfs_bmap_free *flist, xfs_extlen_t tot);
+ struct xfs_defer_ops *flist, xfs_extlen_t tot);
extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t *inum,
struct xfs_name *ci_name);
extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t ino,
xfs_fsblock_t *first,
- struct xfs_bmap_free *flist, xfs_extlen_t tot);
+ struct xfs_defer_ops *flist, xfs_extlen_t tot);
extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t inum,
xfs_fsblock_t *first,
- struct xfs_bmap_free *flist, xfs_extlen_t tot);
+ struct xfs_defer_ops *flist, xfs_extlen_t tot);
extern int xfs_dir_canenter(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name);
struct xfs_mount *mp,
xfs_agnumber_t agno,
struct xfs_inobt_rec_incore *rec,
- struct xfs_bmap_free *flist)
+ struct xfs_defer_ops *flist)
{
xfs_agblock_t sagbno = XFS_AGINO_TO_AGBNO(mp, rec->ir_startino);
int startidx, endidx;
struct xfs_trans *tp,
struct xfs_buf *agbp,
xfs_agino_t agino,
- struct xfs_bmap_free *flist,
+ struct xfs_defer_ops *flist,
struct xfs_icluster *xic,
struct xfs_inobt_rec_incore *orec)
{
xfs_difree(
struct xfs_trans *tp, /* transaction pointer */
xfs_ino_t inode, /* inode to be freed */
- struct xfs_bmap_free *flist, /* extents to free */
+ struct xfs_defer_ops *flist, /* extents to free */
struct xfs_icluster *xic) /* cluster info if deleted */
{
/* REFERENCED */
xfs_difree(
struct xfs_trans *tp, /* transaction pointer */
xfs_ino_t inode, /* inode to be freed */
- struct xfs_bmap_free *flist, /* extents to free */
+ struct xfs_defer_ops *flist, /* extents to free */
struct xfs_icluster *ifree); /* cluster info if deleted */
/*
* item logged to try to account for the overhead of the transaction mechanism.
*
* Note: Most of the reservations underestimate the number of allocation
- * groups into which they could free extents in the xfs_bmap_finish() call.
+ * groups into which they could free extents in the xfs_defer_finish() call.
* This is because the number in the worst case is quite high and quite
- * unusual. In order to fix this we need to change xfs_bmap_finish() to free
+ * unusual. In order to fix this we need to change xfs_defer_finish() to free
* extents in only a single AG at a time. This will require changes to the
* EFI code as well, however, so that the EFI for the extents not freed is
* logged again in each transaction. See SGI PV #261917.
static void fail(char *msg, int i);
static struct xfs_trans * getres(struct xfs_mount *mp, uint blocks);
static void rsvfile(xfs_mount_t *mp, xfs_inode_t *ip, long long len);
-static int newfile(xfs_trans_t *tp, xfs_inode_t *ip, xfs_bmap_free_t *flist,
+static int newfile(xfs_trans_t *tp, xfs_inode_t *ip, struct xfs_defer_ops *flist,
xfs_fsblock_t *first, int dolocal, int logit, char *buf, int len);
static char *newregfile(char **pp, int *len);
static void rtinit(xfs_mount_t *mp);
newfile(
xfs_trans_t *tp,
xfs_inode_t *ip,
- xfs_bmap_free_t *flist,
+ struct xfs_defer_ops *flist,
xfs_fsblock_t *first,
int dolocal,
int logit,
struct xfs_name *name,
xfs_ino_t inum,
xfs_fsblock_t *first,
- xfs_bmap_free_t *flist)
+ struct xfs_defer_ops *flist)
{
int error;
int rsv;
int error;
xfs_fsblock_t first;
int flags;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
int fmt;
int i;
xfs_inode_t *ip;
xname.len = name ? strlen(name) : 0;
xname.type = 0;
flags = XFS_ILOG_CORE;
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
switch (fmt) {
case IF_REGULAR:
buf = newregfile(pp, &len);
newdirent(mp, tp, pip, &xname, ip->i_ino, &first, &flist);
libxfs_trans_log_inode(tp, ip, flags);
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
if (error)
fail(_("Pre-allocated file creation failed"), error);
libxfs_trans_commit(tp);
}
newdirectory(mp, tp, ip, pip);
libxfs_trans_log_inode(tp, ip, flags);
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
if (error)
fail(_("Directory creation failed"), error);
libxfs_trans_commit(tp);
fail(_("Unknown format"), EINVAL);
}
libxfs_trans_log_inode(tp, ip, flags);
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
if (error) {
fail(_("Error encountered creating file from prototype file"),
error);
xfs_bmbt_irec_t *ep;
int error;
xfs_fsblock_t first;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
int i;
xfs_bmbt_irec_t map[XFS_BMAP_MAX_NMAP];
xfs_extlen_t nsumblocks;
libxfs_trans_ijoin(tp, rbmip, 0);
bno = 0;
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
while (bno < mp->m_sb.sb_rbmblocks) {
nmap = XFS_BMAP_MAX_NMAP;
error = -libxfs_bmapi_write(tp, rbmip, bno,
}
}
- error = -libxfs_bmap_finish(&tp, &flist, rbmip);
+ error = -libxfs_defer_finish(&tp, &flist, rbmip);
if (error) {
fail(_("Completion of the realtime bitmap failed"), error);
}
res_failed(i);
libxfs_trans_ijoin(tp, rsumip, 0);
bno = 0;
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
while (bno < nsumblocks) {
nmap = XFS_BMAP_MAX_NMAP;
error = -libxfs_bmapi_write(tp, rsumip, bno,
bno += ep->br_blockcount;
}
}
- error = -libxfs_bmap_finish(&tp, &flist, rsumip);
+ error = -libxfs_defer_finish(&tp, &flist, rsumip);
if (error) {
fail(_("Completion of the realtime summary failed"), error);
}
if (i)
res_failed(i);
libxfs_trans_ijoin(tp, rbmip, 0);
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
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));
fail(_("Error initializing the realtime space"),
error);
}
- error = -libxfs_bmap_finish(&tp, &flist, rbmip);
+ error = -libxfs_defer_finish(&tp, &flist, rbmip);
if (error) {
fail(_("Error completing the realtime space"), error);
}
int i;
int nmap;
int error;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
xfs_fileoff_t bno;
xfs_bmbt_irec_t map[XFS_BMAP_MAX_NMAP];
int vers;
libxfs_trans_ijoin(tp, ip, 0);
bno = 0;
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
while (bno < mp->m_sb.sb_rbmblocks) {
nmap = XFS_BMAP_MAX_NMAP;
error = -libxfs_bmapi_write(tp, ip, bno,
bno += ep->br_blockcount;
}
}
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
if (error) {
do_error(
_("allocation of the realtime bitmap failed, error = %d\n"),
int nmap;
int error;
int nsumblocks;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
xfs_fileoff_t bno;
xfs_bmbt_irec_t map[XFS_BMAP_MAX_NMAP];
int vers;
* then allocate blocks for file and fill with zeroes (stolen
* from mkfs)
*/
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
nsumblocks = mp->m_rsumsize >> mp->m_sb.sb_blocklog;
tres.tr_logres = BBTOB(128);
libxfs_trans_ijoin(tp, ip, 0);
bno = 0;
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
while (bno < nsumblocks) {
nmap = XFS_BMAP_MAX_NMAP;
error = -libxfs_bmapi_write(tp, ip, bno,
bno += ep->br_blockcount;
}
}
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
if (error) {
do_error(
_("allocation of the realtime summary ino failed, error = %d\n"),
int ino_offset = 0;
int i;
int error;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
const int mode = 0755;
int nres;
struct xfs_name xname;
/*
* could not be found, create it
*/
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
nres = XFS_MKDIR_SPACE_RES(mp, xname.len);
i = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_mkdir, nres, 0, 0, &tp);
if (i)
libxfs_dir_init(tp, ip, pip);
libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
if (error) {
do_error(_("%s directory creation failed -- bmapf error %d\n"),
ORPHANAGE, error);
xfs_inode_t *ino_p;
xfs_trans_t *tp;
xfs_fsblock_t first;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
int err;
unsigned char fname[MAXPATHLEN + 1];
int nres;
libxfs_trans_ijoin(tp, orphanage_ip, 0);
libxfs_trans_ijoin(tp, ino_p, 0);
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
err = -libxfs_dir_createname(tp, orphanage_ip, &xname,
ino, &first, &flist, nres);
if (err)
inc_nlink(VFS_I(ino_p));
libxfs_trans_log_inode(tp, ino_p, XFS_ILOG_CORE);
- err = -libxfs_bmap_finish(&tp, &flist, ino_p);
+ err = -libxfs_defer_finish(&tp, &flist, ino_p);
if (err)
do_error(
_("bmap finish failed (err - %d), filesystem may be out of space\n"),
libxfs_trans_ijoin(tp, orphanage_ip, 0);
libxfs_trans_ijoin(tp, ino_p, 0);
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
err = -libxfs_dir_createname(tp, orphanage_ip, &xname,
ino, &first, &flist, nres);
err);
}
- err = -libxfs_bmap_finish(&tp, &flist, ino_p);
+ err = -libxfs_defer_finish(&tp, &flist, ino_p);
if (err)
do_error(
_("bmap finish failed (%d), filesystem may be out of space\n"),
libxfs_trans_ijoin(tp, orphanage_ip, 0);
libxfs_trans_ijoin(tp, ino_p, 0);
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
err = -libxfs_dir_createname(tp, orphanage_ip, &xname, ino,
&first, &flist, nres);
if (err)
set_nlink(VFS_I(ino_p), 1);
libxfs_trans_log_inode(tp, ino_p, XFS_ILOG_CORE);
- err = -libxfs_bmap_finish(&tp, &flist, ino_p);
+ err = -libxfs_defer_finish(&tp, &flist, ino_p);
if (err)
do_error(
_("bmap finish failed (%d), filesystem may be out of space\n"),
xfs_trans_t *tp;
xfs_fileoff_t lastblock;
xfs_fsblock_t firstblock;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
xfs_inode_t pip;
dir_hash_ent_t *p;
int done;
xfs_dir_ino_validate(mp, pip.i_ino))
pip.i_ino = mp->m_sb.sb_rootino;
- xfs_bmap_init(&flist, &firstblock);
+ libxfs_defer_init(&flist, &firstblock);
nres = XFS_REMOVE_SPACE_RES(mp);
error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_remove, nres, 0, 0, &tp);
goto out_bmap_cancel;
}
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
libxfs_trans_commit(tp);
libxfs_trans_ijoin(tp, ip, 0);
- xfs_bmap_init(&flist, &firstblock);
+ libxfs_defer_init(&flist, &firstblock);
error = -libxfs_dir_createname(tp, ip, &p->name, p->inum,
&firstblock, &flist, nres);
if (error) {
goto out_bmap_cancel;
}
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
if (error) {
do_warn(
_("bmap finish failed (%d), filesystem may be out of space\n"),
return;
out_bmap_cancel:
- libxfs_bmap_cancel(&flist);
+ libxfs_defer_cancel(&flist);
libxfs_trans_cancel(tp);
return;
}
xfs_da_args_t args;
int error;
xfs_fsblock_t firstblock;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
int nres;
xfs_trans_t *tp;
libxfs_trans_ijoin(tp, ip, 0);
libxfs_trans_bjoin(tp, bp);
memset(&args, 0, sizeof(args));
- xfs_bmap_init(&flist, &firstblock);
+ libxfs_defer_init(&flist, &firstblock);
args.dp = ip;
args.trans = tp;
args.firstblock = &firstblock;
if (error)
do_error(_("shrink_inode failed inode %" PRIu64 " block %u\n"),
ip->i_ino, da_bno);
- libxfs_bmap_finish(&tp, &flist, ip);
+ libxfs_defer_finish(&tp, &flist, ip);
libxfs_trans_commit(tp);
}
char *endptr;
int error;
xfs_fsblock_t firstblock;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
char fname[MAXNAMELEN + 1];
freetab_t *freetab;
int i;
libxfs_trans_ijoin(tp, ip, 0);
libxfs_trans_bjoin(tp, bp);
libxfs_trans_bhold(tp, bp);
- xfs_bmap_init(&flist, &firstblock);
+ libxfs_defer_init(&flist, &firstblock);
if (be32_to_cpu(d->magic) != wantmagic) {
do_warn(
_("bad directory block magic # %#x for directory inode %" PRIu64 " block %d: "),
libxfs_dir2_data_freescan(mp->m_dir_geo, M_DIROPS(mp), d, &i);
if (needlog)
libxfs_dir2_data_log_header(&da, bp);
- libxfs_bmap_finish(&tp, &flist, ip);
+ libxfs_defer_finish(&tp, &flist, ip);
libxfs_trans_commit(tp);
/* record the largest free space in the freetab for later checking */
int ino_offset)
{
xfs_ino_t ino;
- xfs_bmap_free_t flist;
+ struct xfs_defer_ops flist;
xfs_fsblock_t first;
xfs_inode_t *ip;
xfs_trans_t *tp;
libxfs_trans_ijoin(tp, ip, 0);
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
error = -libxfs_dir_createname(tp, ip, &xfs_name_dotdot,
ip->i_ino, &first, &flist, nres);
libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
ASSERT(error == 0);
libxfs_trans_commit(tp);
libxfs_trans_ijoin(tp, ip, 0);
- xfs_bmap_init(&flist, &first);
+ libxfs_defer_init(&flist, &first);
error = -libxfs_dir_createname(tp, ip, &xfs_name_dot,
ip->i_ino, &first, &flist, nres);
libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
- error = -libxfs_bmap_finish(&tp, &flist, ip);
+ error = -libxfs_defer_finish(&tp, &flist, ip);
ASSERT(error == 0);
libxfs_trans_commit(tp);
}
projects / thirdparty / xfsprogs-dev.git / commitdiff
