Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0
       2             : /*
       3             :  * Copyright (c) 2000,2005 Silicon Graphics, Inc.
       4             :  * All Rights Reserved.
       5             :  */
       6             : #include "xfs.h"
       7             : #include "xfs_fs.h"
       8             : #include "xfs_shared.h"
       9             : #include "xfs_format.h"
      10             : #include "xfs_log_format.h"
      11             : #include "xfs_trans_resv.h"
      12             : #include "xfs_mount.h"
      13             : #include "xfs_inode.h"
      14             : #include "xfs_trans.h"
      15             : #include "xfs_trans_priv.h"
      16             : #include "xfs_inode_item.h"
      17             : 
      18             : #include <linux/iversion.h>
      19             : 
      20             : /*
      21             :  * Add a locked inode to the transaction.
      22             :  *
      23             :  * The inode must be locked, and it cannot be associated with any transaction.
      24             :  * If lock_flags is non-zero the inode will be unlocked on transaction commit.
      25             :  */
      26             : void
      27  3817455987 : xfs_trans_ijoin(
      28             :         struct xfs_trans        *tp,
      29             :         struct xfs_inode        *ip,
      30             :         uint                    lock_flags)
      31             : {
      32  3817455987 :         struct xfs_inode_log_item *iip;
      33             : 
      34  3817455987 :         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
      35  3816271661 :         if (ip->i_itemp == NULL)
      36    79120377 :                 xfs_inode_item_init(ip, ip->i_mount);
      37  3816434925 :         iip = ip->i_itemp;
      38             : 
      39  3816434925 :         ASSERT(iip->ili_lock_flags == 0);
      40  3816434925 :         iip->ili_lock_flags = lock_flags;
      41  7636062074 :         ASSERT(!xfs_iflags_test(ip, XFS_ISTALE));
      42             : 
      43             :         /* Reset the per-tx dirty context and add the item to the tx. */
      44  3819627149 :         iip->ili_dirty_flags = 0;
      45  3819627149 :         xfs_trans_add_item(tp, &iip->ili_item);
      46  3817653784 : }
      47             : 
      48             : /*
      49             :  * Transactional inode timestamp update. Requires the inode to be locked and
      50             :  * joined to the transaction supplied. Relies on the transaction subsystem to
      51             :  * track dirty state and update/writeback the inode accordingly.
      52             :  */
      53             : void
      54   769009729 : xfs_trans_ichgtime(
      55             :         struct xfs_trans        *tp,
      56             :         struct xfs_inode        *ip,
      57             :         int                     flags)
      58             : {
      59   769009729 :         struct inode            *inode = VFS_I(ip);
      60   769009729 :         struct timespec64       tv;
      61             : 
      62   769009729 :         ASSERT(tp);
      63   769009729 :         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
      64             : 
      65   768669033 :         tv = current_time(inode);
      66             : 
      67   768834975 :         if (flags & XFS_ICHGTIME_MOD)
      68   277489222 :                 inode->i_mtime = tv;
      69   768834975 :         if (flags & XFS_ICHGTIME_CHG)
      70   768824316 :                 inode->i_ctime = tv;
      71   768834975 :         if (flags & XFS_ICHGTIME_CREATE)
      72           0 :                 ip->i_crtime = tv;
      73   768834975 : }
      74             : 
      75             : /*
      76             :  * This is called to mark the fields indicated in fieldmask as needing to be
      77             :  * logged when the transaction is committed.  The inode must already be
      78             :  * associated with the given transaction. All we do here is record where the
      79             :  * inode was dirtied and mark the transaction and inode log item dirty;
      80             :  * everything else is done in the ->precommit log item operation after the
      81             :  * changes in the transaction have been completed.
      82             :  */
      83             : void
      84  4561647945 : xfs_trans_log_inode(
      85             :         struct xfs_trans        *tp,
      86             :         struct xfs_inode        *ip,
      87             :         uint                    flags)
      88             : {
      89  4561647945 :         struct xfs_inode_log_item *iip = ip->i_itemp;
      90  4561647945 :         struct inode            *inode = VFS_I(ip);
      91             : 
      92  4561647945 :         ASSERT(iip);
      93  4561647945 :         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
      94  9125488421 :         ASSERT(!xfs_iflags_test(ip, XFS_ISTALE));
      95             : 
      96  4564934874 :         tp->t_flags |= XFS_TRANS_DIRTY;
      97             : 
      98             :         /*
      99             :          * First time we log the inode in a transaction, bump the inode change
     100             :          * counter if it is configured for this to occur. While we have the
     101             :          * inode locked exclusively for metadata modification, we can usually
     102             :          * avoid setting XFS_ILOG_CORE if no one has queried the value since
     103             :          * the last time it was incremented. If we have XFS_ILOG_CORE already
     104             :          * set however, then go ahead and bump the i_version counter
     105             :          * unconditionally.
     106             :          */
     107  4564934874 :         if (!test_and_set_bit(XFS_LI_DIRTY, &iip->ili_item.li_flags)) {
     108  5368082513 :                 if (IS_I_VERSION(inode) &&
     109  2684250222 :                     inode_maybe_inc_iversion(inode, flags & XFS_ILOG_CORE))
     110  2524543737 :                         flags |= XFS_ILOG_IVERSION;
     111             :         }
     112             : 
     113  4564546641 :         iip->ili_dirty_flags |= flags;
     114  4564546641 : }
     115             : 
     116             : int
     117     8223224 : xfs_trans_roll_inode(
     118             :         struct xfs_trans        **tpp,
     119             :         struct xfs_inode        *ip)
     120             : {
     121     8223224 :         int                     error;
     122             : 
     123     8223224 :         xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE);
     124     8228067 :         error = xfs_trans_roll(tpp);
     125     8227265 :         if (!error)
     126     8226599 :                 xfs_trans_ijoin(*tpp, ip, 0);
     127     8228852 :         return error;
     128             : }