Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0+
       2             : /*
       3             :  * Copyright (C) 2016 Oracle.  All Rights Reserved.
       4             :  * Author: Darrick J. Wong <darrick.wong@oracle.com>
       5             :  */
       6             : #ifndef __XFS_REFCOUNT_H__
       7             : #define __XFS_REFCOUNT_H__
       8             : 
       9             : struct xfs_trans;
      10             : struct xfs_mount;
      11             : struct xfs_perag;
      12             : struct xfs_btree_cur;
      13             : struct xfs_bmbt_irec;
      14             : struct xfs_refcount_irec;
      15             : 
      16             : extern int xfs_refcount_lookup_le(struct xfs_btree_cur *cur,
      17             :                 enum xfs_refc_domain domain, xfs_agblock_t bno, int *stat);
      18             : extern int xfs_refcount_lookup_ge(struct xfs_btree_cur *cur,
      19             :                 enum xfs_refc_domain domain, xfs_agblock_t bno, int *stat);
      20             : extern int xfs_refcount_lookup_eq(struct xfs_btree_cur *cur,
      21             :                 enum xfs_refc_domain domain, xfs_agblock_t bno, int *stat);
      22             : extern int xfs_refcount_get_rec(struct xfs_btree_cur *cur,
      23             :                 struct xfs_refcount_irec *irec, int *stat);
      24             : 
      25             : static inline uint32_t
      26             : xfs_refcount_encode_startblock(
      27             :         xfs_agblock_t           startblock,
      28             :         enum xfs_refc_domain    domain)
      29             : {
      30 36054402813 :         uint32_t                start;
      31             : 
      32             :         /*
      33             :          * low level btree operations need to handle the generic btree range
      34             :          * query functions (which set rc_domain == -1U), so we check that the
      35             :          * domain is /not/ shared.
      36             :          */
      37 36054402813 :         start = startblock & ~XFS_REFC_COWFLAG;
      38 36054402813 :         if (domain != XFS_REFC_DOMAIN_SHARED)
      39  9801483826 :                 start |= XFS_REFC_COWFLAG;
      40             : 
      41 36054402813 :         return start;
      42             : }
      43             : 
      44             : enum xfs_refcount_intent_type {
      45             :         XFS_REFCOUNT_INCREASE = 1,
      46             :         XFS_REFCOUNT_DECREASE,
      47             :         XFS_REFCOUNT_ALLOC_COW,
      48             :         XFS_REFCOUNT_FREE_COW,
      49             : };
      50             : 
      51             : struct xfs_refcount_intent {
      52             :         struct list_head                        ri_list;
      53             :         struct xfs_perag                        *ri_pag;
      54             :         enum xfs_refcount_intent_type           ri_type;
      55             :         xfs_extlen_t                            ri_blockcount;
      56             :         xfs_fsblock_t                           ri_startblock;
      57             : };
      58             : 
      59             : /* Check that the refcount is appropriate for the record domain. */
      60             : static inline bool
      61  2595505227 : xfs_refcount_check_domain(
      62             :         const struct xfs_refcount_irec  *irec)
      63             : {
      64  2595505227 :         if (irec->rc_domain == XFS_REFC_DOMAIN_COW && irec->rc_refcount != 1)
      65             :                 return false;
      66  2595507049 :         if (irec->rc_domain == XFS_REFC_DOMAIN_SHARED && irec->rc_refcount < 2)
      67           0 :                 return false;
      68             :         return true;
      69             : }
      70             : 
      71             : void xfs_refcount_update_get_group(struct xfs_mount *mp,
      72             :                 struct xfs_refcount_intent *ri);
      73             : 
      74             : void xfs_refcount_increase_extent(struct xfs_trans *tp,
      75             :                 struct xfs_bmbt_irec *irec);
      76             : void xfs_refcount_decrease_extent(struct xfs_trans *tp,
      77             :                 struct xfs_bmbt_irec *irec);
      78             : 
      79             : extern void xfs_refcount_finish_one_cleanup(struct xfs_trans *tp,
      80             :                 struct xfs_btree_cur *rcur, int error);
      81             : extern int xfs_refcount_finish_one(struct xfs_trans *tp,
      82             :                 struct xfs_refcount_intent *ri, struct xfs_btree_cur **pcur);
      83             : 
      84             : extern int xfs_refcount_find_shared(struct xfs_btree_cur *cur,
      85             :                 xfs_agblock_t agbno, xfs_extlen_t aglen, xfs_agblock_t *fbno,
      86             :                 xfs_extlen_t *flen, bool find_end_of_shared);
      87             : 
      88             : void xfs_refcount_alloc_cow_extent(struct xfs_trans *tp, xfs_fsblock_t fsb,
      89             :                 xfs_extlen_t len);
      90             : void xfs_refcount_free_cow_extent(struct xfs_trans *tp, xfs_fsblock_t fsb,
      91             :                 xfs_extlen_t len);
      92             : extern int xfs_refcount_recover_cow_leftovers(struct xfs_mount *mp,
      93             :                 struct xfs_perag *pag);
      94             : 
      95             : /*
      96             :  * While we're adjusting the refcounts records of an extent, we have
      97             :  * to keep an eye on the number of extents we're dirtying -- run too
      98             :  * many in a single transaction and we'll exceed the transaction's
      99             :  * reservation and crash the fs.  Each record adds 12 bytes to the
     100             :  * log (plus any key updates) so we'll conservatively assume 32 bytes
     101             :  * per record.  We must also leave space for btree splits on both ends
     102             :  * of the range and space for the CUD and a new CUI.
     103             :  *
     104             :  * Each EFI that we attach to the transaction is assumed to consume ~32 bytes.
     105             :  * This is a low estimate for an EFI tracking a single extent (16 bytes for the
     106             :  * EFI header, 16 for the extent, and 12 for the xlog op header), but the
     107             :  * estimate is acceptable if there's more than one extent being freed.
     108             :  * In the worst case of freeing every other block during a refcount decrease
     109             :  * operation, we amortize the space used for one EFI log item across 16
     110             :  * extents.
     111             :  */
     112             : #define XFS_REFCOUNT_ITEM_OVERHEAD      32
     113             : 
     114             : extern int xfs_refcount_has_records(struct xfs_btree_cur *cur,
     115             :                 enum xfs_refc_domain domain, xfs_agblock_t bno,
     116             :                 xfs_extlen_t len, enum xbtree_recpacking *outcome);
     117             : union xfs_btree_rec;
     118             : extern void xfs_refcount_btrec_to_irec(const union xfs_btree_rec *rec,
     119             :                 struct xfs_refcount_irec *irec);
     120             : xfs_failaddr_t xfs_refcount_check_irec(struct xfs_btree_cur *cur,
     121             :                 const struct xfs_refcount_irec *irec);
     122             : extern int xfs_refcount_insert(struct xfs_btree_cur *cur,
     123             :                 struct xfs_refcount_irec *irec, int *stat);
     124             : 
     125             : extern struct kmem_cache        *xfs_refcount_intent_cache;
     126             : 
     127             : int __init xfs_refcount_intent_init_cache(void);
     128             : void xfs_refcount_intent_destroy_cache(void);
     129             : 
     130             : #endif  /* __XFS_REFCOUNT_H__ */