fs/xfs/libxfs/xfs_defer.h

   1 /*
   2  * Copyright (C) 2016 Oracle.  All Rights Reserved.
   3  *
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it would be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write the Free Software Foundation,
  18  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 #ifndef __XFS_DEFER_H__
  21 #define __XFS_DEFER_H__
  22
  23 struct xfs_defer_op_type;
  24
  25 /*
  26  * Save a log intent item and a list of extents, so that we can replay
  27  * whatever action had to happen to the extent list and file the log done
  28  * item.
  29  */
  30 struct xfs_defer_pending {
  31         const struct xfs_defer_op_type  *dfp_type;      /* function pointers */
  32         struct list_head                dfp_list;       /* pending items */
  33         void                            *dfp_intent;    /* log intent item */
  34         void                            *dfp_done;      /* log done item */
  35         struct list_head                dfp_work;       /* work items */
  36         unsigned int                    dfp_count;      /* # extent items */
  37 };
  38
  39 /*
  40  * Header for deferred operation list.
  41  *
  42  * dop_low is used by the allocator to activate the lowspace algorithm -
  43  * when free space is running low the extent allocator may choose to
  44  * allocate an extent from an AG without leaving sufficient space for
  45  * a btree split when inserting the new extent.  In this case the allocator
  46  * will enable the lowspace algorithm which is supposed to allow further
  47  * allocations (such as btree splits and newroots) to allocate from
  48  * sequential AGs.  In order to avoid locking AGs out of order the lowspace
  49  * algorithm will start searching for free space from AG 0.  If the correct
  50  * transaction reservations have been made then this algorithm will eventually
  51  * find all the space it needs.
  52  */
  53 enum xfs_defer_ops_type {
  54         XFS_DEFER_OPS_TYPE_BMAP,
  55         XFS_DEFER_OPS_TYPE_REFCOUNT,
  56         XFS_DEFER_OPS_TYPE_RMAP,
  57         XFS_DEFER_OPS_TYPE_FREE,
  58         XFS_DEFER_OPS_TYPE_MAX,
  59 };
  60
  61 #define XFS_DEFER_OPS_NR_INODES 2       /* join up to two inodes */
  62 #define XFS_DEFER_OPS_NR_BUFS   2       /* join up to two buffers */
  63
  64 struct xfs_defer_ops {
  65         bool                    dop_committed;  /* did any trans commit? */
  66         bool                    dop_low;        /* alloc in low mode */
  67         struct list_head        dop_intake;     /* unlogged pending work */
  68         struct list_head        dop_pending;    /* logged pending work */
  69
  70         /* relog these with each roll */
  71         struct xfs_inode        *dop_inodes[XFS_DEFER_OPS_NR_INODES];
  72         struct xfs_buf          *dop_bufs[XFS_DEFER_OPS_NR_BUFS];
  73 };
  74
  75 void xfs_defer_add(struct xfs_defer_ops *dop, enum xfs_defer_ops_type type,
  76                 struct list_head *h);
  77 int xfs_defer_finish(struct xfs_trans **tp, struct xfs_defer_ops *dop);
  78 void xfs_defer_cancel(struct xfs_defer_ops *dop);
  79 void xfs_defer_init(struct xfs_defer_ops *dop, xfs_fsblock_t *fbp);
  80 bool xfs_defer_has_unfinished_work(struct xfs_defer_ops *dop);
  81 int xfs_defer_ijoin(struct xfs_defer_ops *dop, struct xfs_inode *ip);
  82 int xfs_defer_bjoin(struct xfs_defer_ops *dop, struct xfs_buf *bp);
  83
  84 /* Description of a deferred type. */
  85 struct xfs_defer_op_type {
  86         enum xfs_defer_ops_type type;
  87         unsigned int            max_items;
  88         void (*abort_intent)(void *);
  89         void *(*create_done)(struct xfs_trans *, void *, unsigned int);
  90         int (*finish_item)(struct xfs_trans *, struct xfs_defer_ops *,
  91                         struct list_head *, void *, void **);
  92         void (*finish_cleanup)(struct xfs_trans *, void *, int);
  93         void (*cancel_item)(struct list_head *);
  94         int (*diff_items)(void *, struct list_head *, struct list_head *);
  95         void *(*create_intent)(struct xfs_trans *, uint);
  96         void (*log_item)(struct xfs_trans *, void *, struct list_head *);
  97 };
  98
  99 void xfs_defer_init_op_type(const struct xfs_defer_op_type *type);
 100
 101 #endif /* __XFS_DEFER_H__ */