Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 2 | * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. |
| 3 | * All Rights Reserved. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 5 | * This program is free software; you can redistribute it and/or |
| 6 | * modify it under the terms of the GNU General Public License as |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * published by the Free Software Foundation. |
| 8 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 9 | * This program is distributed in the hope that it would be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | * GNU General Public License for more details. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 14 | * You should have received a copy of the GNU General Public License |
| 15 | * along with this program; if not, write the Free Software Foundation, |
| 16 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | */ |
| 18 | #ifndef __XFS_TRANS_H__ |
| 19 | #define __XFS_TRANS_H__ |
| 20 | |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 21 | struct xfs_log_item; |
| 22 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | /* |
| 24 | * This is the structure written in the log at the head of |
| 25 | * every transaction. It identifies the type and id of the |
| 26 | * transaction, and contains the number of items logged by |
| 27 | * the transaction so we know how many to expect during recovery. |
| 28 | * |
| 29 | * Do not change the below structure without redoing the code in |
| 30 | * xlog_recover_add_to_trans() and xlog_recover_add_to_cont_trans(). |
| 31 | */ |
| 32 | typedef struct xfs_trans_header { |
| 33 | uint th_magic; /* magic number */ |
| 34 | uint th_type; /* transaction type */ |
| 35 | __int32_t th_tid; /* transaction id (unused) */ |
| 36 | uint th_num_items; /* num items logged by trans */ |
| 37 | } xfs_trans_header_t; |
| 38 | |
| 39 | #define XFS_TRANS_HEADER_MAGIC 0x5452414e /* TRAN */ |
| 40 | |
| 41 | /* |
| 42 | * Log item types. |
| 43 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | #define XFS_LI_EFI 0x1236 |
| 45 | #define XFS_LI_EFD 0x1237 |
| 46 | #define XFS_LI_IUNLINK 0x1238 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | #define XFS_LI_INODE 0x123b /* aligned ino chunks, var-size ibufs */ |
| 48 | #define XFS_LI_BUF 0x123c /* v2 bufs, variable sized inode bufs */ |
| 49 | #define XFS_LI_DQUOT 0x123d |
| 50 | #define XFS_LI_QUOTAOFF 0x123e |
| 51 | |
Dave Chinner | 9abbc53 | 2010-04-13 15:06:46 +1000 | [diff] [blame] | 52 | #define XFS_LI_TYPE_DESC \ |
| 53 | { XFS_LI_EFI, "XFS_LI_EFI" }, \ |
| 54 | { XFS_LI_EFD, "XFS_LI_EFD" }, \ |
| 55 | { XFS_LI_IUNLINK, "XFS_LI_IUNLINK" }, \ |
| 56 | { XFS_LI_INODE, "XFS_LI_INODE" }, \ |
| 57 | { XFS_LI_BUF, "XFS_LI_BUF" }, \ |
| 58 | { XFS_LI_DQUOT, "XFS_LI_DQUOT" }, \ |
| 59 | { XFS_LI_QUOTAOFF, "XFS_LI_QUOTAOFF" } |
| 60 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | /* |
| 62 | * Transaction types. Used to distinguish types of buffers. |
| 63 | */ |
| 64 | #define XFS_TRANS_SETATTR_NOT_SIZE 1 |
| 65 | #define XFS_TRANS_SETATTR_SIZE 2 |
| 66 | #define XFS_TRANS_INACTIVE 3 |
| 67 | #define XFS_TRANS_CREATE 4 |
| 68 | #define XFS_TRANS_CREATE_TRUNC 5 |
| 69 | #define XFS_TRANS_TRUNCATE_FILE 6 |
| 70 | #define XFS_TRANS_REMOVE 7 |
| 71 | #define XFS_TRANS_LINK 8 |
| 72 | #define XFS_TRANS_RENAME 9 |
| 73 | #define XFS_TRANS_MKDIR 10 |
| 74 | #define XFS_TRANS_RMDIR 11 |
| 75 | #define XFS_TRANS_SYMLINK 12 |
| 76 | #define XFS_TRANS_SET_DMATTRS 13 |
| 77 | #define XFS_TRANS_GROWFS 14 |
| 78 | #define XFS_TRANS_STRAT_WRITE 15 |
| 79 | #define XFS_TRANS_DIOSTRAT 16 |
Christoph Hellwig | 13e6d5c | 2009-08-31 21:00:31 -0300 | [diff] [blame] | 80 | /* 17 was XFS_TRANS_WRITE_SYNC */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | #define XFS_TRANS_WRITEID 18 |
| 82 | #define XFS_TRANS_ADDAFORK 19 |
| 83 | #define XFS_TRANS_ATTRINVAL 20 |
| 84 | #define XFS_TRANS_ATRUNCATE 21 |
| 85 | #define XFS_TRANS_ATTR_SET 22 |
| 86 | #define XFS_TRANS_ATTR_RM 23 |
| 87 | #define XFS_TRANS_ATTR_FLAG 24 |
| 88 | #define XFS_TRANS_CLEAR_AGI_BUCKET 25 |
| 89 | #define XFS_TRANS_QM_SBCHANGE 26 |
| 90 | /* |
| 91 | * Dummy entries since we use the transaction type to index into the |
| 92 | * trans_type[] in xlog_recover_print_trans_head() |
| 93 | */ |
| 94 | #define XFS_TRANS_DUMMY1 27 |
| 95 | #define XFS_TRANS_DUMMY2 28 |
| 96 | #define XFS_TRANS_QM_QUOTAOFF 29 |
| 97 | #define XFS_TRANS_QM_DQALLOC 30 |
| 98 | #define XFS_TRANS_QM_SETQLIM 31 |
| 99 | #define XFS_TRANS_QM_DQCLUSTER 32 |
| 100 | #define XFS_TRANS_QM_QINOCREATE 33 |
| 101 | #define XFS_TRANS_QM_QUOTAOFF_END 34 |
| 102 | #define XFS_TRANS_SB_UNIT 35 |
| 103 | #define XFS_TRANS_FSYNC_TS 36 |
| 104 | #define XFS_TRANS_GROWFSRT_ALLOC 37 |
| 105 | #define XFS_TRANS_GROWFSRT_ZERO 38 |
| 106 | #define XFS_TRANS_GROWFSRT_FREE 39 |
| 107 | #define XFS_TRANS_SWAPEXT 40 |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 108 | #define XFS_TRANS_SB_COUNT 41 |
Dave Chinner | 71e330b | 2010-05-21 14:37:18 +1000 | [diff] [blame] | 109 | #define XFS_TRANS_CHECKPOINT 42 |
| 110 | #define XFS_TRANS_TYPE_MAX 42 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | /* new transaction types need to be reflected in xfs_logprint(8) */ |
| 112 | |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 113 | #define XFS_TRANS_TYPES \ |
| 114 | { XFS_TRANS_SETATTR_NOT_SIZE, "SETATTR_NOT_SIZE" }, \ |
| 115 | { XFS_TRANS_SETATTR_SIZE, "SETATTR_SIZE" }, \ |
| 116 | { XFS_TRANS_INACTIVE, "INACTIVE" }, \ |
| 117 | { XFS_TRANS_CREATE, "CREATE" }, \ |
| 118 | { XFS_TRANS_CREATE_TRUNC, "CREATE_TRUNC" }, \ |
| 119 | { XFS_TRANS_TRUNCATE_FILE, "TRUNCATE_FILE" }, \ |
| 120 | { XFS_TRANS_REMOVE, "REMOVE" }, \ |
| 121 | { XFS_TRANS_LINK, "LINK" }, \ |
| 122 | { XFS_TRANS_RENAME, "RENAME" }, \ |
| 123 | { XFS_TRANS_MKDIR, "MKDIR" }, \ |
| 124 | { XFS_TRANS_RMDIR, "RMDIR" }, \ |
| 125 | { XFS_TRANS_SYMLINK, "SYMLINK" }, \ |
| 126 | { XFS_TRANS_SET_DMATTRS, "SET_DMATTRS" }, \ |
| 127 | { XFS_TRANS_GROWFS, "GROWFS" }, \ |
| 128 | { XFS_TRANS_STRAT_WRITE, "STRAT_WRITE" }, \ |
| 129 | { XFS_TRANS_DIOSTRAT, "DIOSTRAT" }, \ |
| 130 | { XFS_TRANS_WRITEID, "WRITEID" }, \ |
| 131 | { XFS_TRANS_ADDAFORK, "ADDAFORK" }, \ |
| 132 | { XFS_TRANS_ATTRINVAL, "ATTRINVAL" }, \ |
| 133 | { XFS_TRANS_ATRUNCATE, "ATRUNCATE" }, \ |
| 134 | { XFS_TRANS_ATTR_SET, "ATTR_SET" }, \ |
| 135 | { XFS_TRANS_ATTR_RM, "ATTR_RM" }, \ |
| 136 | { XFS_TRANS_ATTR_FLAG, "ATTR_FLAG" }, \ |
| 137 | { XFS_TRANS_CLEAR_AGI_BUCKET, "CLEAR_AGI_BUCKET" }, \ |
| 138 | { XFS_TRANS_QM_SBCHANGE, "QM_SBCHANGE" }, \ |
| 139 | { XFS_TRANS_QM_QUOTAOFF, "QM_QUOTAOFF" }, \ |
| 140 | { XFS_TRANS_QM_DQALLOC, "QM_DQALLOC" }, \ |
| 141 | { XFS_TRANS_QM_SETQLIM, "QM_SETQLIM" }, \ |
| 142 | { XFS_TRANS_QM_DQCLUSTER, "QM_DQCLUSTER" }, \ |
| 143 | { XFS_TRANS_QM_QINOCREATE, "QM_QINOCREATE" }, \ |
| 144 | { XFS_TRANS_QM_QUOTAOFF_END, "QM_QOFF_END" }, \ |
| 145 | { XFS_TRANS_SB_UNIT, "SB_UNIT" }, \ |
| 146 | { XFS_TRANS_FSYNC_TS, "FSYNC_TS" }, \ |
| 147 | { XFS_TRANS_GROWFSRT_ALLOC, "GROWFSRT_ALLOC" }, \ |
| 148 | { XFS_TRANS_GROWFSRT_ZERO, "GROWFSRT_ZERO" }, \ |
| 149 | { XFS_TRANS_GROWFSRT_FREE, "GROWFSRT_FREE" }, \ |
| 150 | { XFS_TRANS_SWAPEXT, "SWAPEXT" }, \ |
| 151 | { XFS_TRANS_SB_COUNT, "SB_COUNT" }, \ |
Dave Chinner | 71e330b | 2010-05-21 14:37:18 +1000 | [diff] [blame] | 152 | { XFS_TRANS_CHECKPOINT, "CHECKPOINT" }, \ |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 153 | { XFS_TRANS_DUMMY1, "DUMMY1" }, \ |
| 154 | { XFS_TRANS_DUMMY2, "DUMMY2" }, \ |
| 155 | { XLOG_UNMOUNT_REC_TYPE, "UNMOUNT" } |
| 156 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | /* |
| 158 | * This structure is used to track log items associated with |
| 159 | * a transaction. It points to the log item and keeps some |
| 160 | * flags to track the state of the log item. It also tracks |
| 161 | * the amount of space needed to log the item it describes |
| 162 | * once we get to commit processing (see xfs_trans_commit()). |
| 163 | */ |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 164 | struct xfs_log_item_desc { |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 165 | struct xfs_log_item *lid_item; |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 166 | struct list_head lid_trans; |
Christoph Hellwig | b393421 | 2011-12-06 21:58:09 +0000 | [diff] [blame] | 167 | unsigned char lid_flags; |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 168 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | |
| 170 | #define XFS_LID_DIRTY 0x1 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | #define XFS_TRANS_MAGIC 0x5452414E /* 'TRAN' */ |
| 173 | /* |
| 174 | * Values for t_flags. |
| 175 | */ |
| 176 | #define XFS_TRANS_DIRTY 0x01 /* something needs to be logged */ |
| 177 | #define XFS_TRANS_SB_DIRTY 0x02 /* superblock is modified */ |
| 178 | #define XFS_TRANS_PERM_LOG_RES 0x04 /* xact took a permanent log res */ |
| 179 | #define XFS_TRANS_SYNC 0x08 /* make commit synchronous */ |
| 180 | #define XFS_TRANS_DQ_DIRTY 0x10 /* at least one dquot in trx dirty */ |
| 181 | #define XFS_TRANS_RESERVE 0x20 /* OK to use reserved data blocks */ |
Jan Kara | d9457dc | 2012-06-12 16:20:39 +0200 | [diff] [blame] | 182 | #define XFS_TRANS_FREEZE_PROT 0x40 /* Transaction has elevated writer |
| 183 | count in superblock */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | |
| 185 | /* |
| 186 | * Values for call flags parameter. |
| 187 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | #define XFS_TRANS_RELEASE_LOG_RES 0x4 |
| 189 | #define XFS_TRANS_ABORT 0x8 |
| 190 | |
| 191 | /* |
| 192 | * Field values for xfs_trans_mod_sb. |
| 193 | */ |
| 194 | #define XFS_TRANS_SB_ICOUNT 0x00000001 |
| 195 | #define XFS_TRANS_SB_IFREE 0x00000002 |
| 196 | #define XFS_TRANS_SB_FDBLOCKS 0x00000004 |
| 197 | #define XFS_TRANS_SB_RES_FDBLOCKS 0x00000008 |
| 198 | #define XFS_TRANS_SB_FREXTENTS 0x00000010 |
| 199 | #define XFS_TRANS_SB_RES_FREXTENTS 0x00000020 |
| 200 | #define XFS_TRANS_SB_DBLOCKS 0x00000040 |
| 201 | #define XFS_TRANS_SB_AGCOUNT 0x00000080 |
| 202 | #define XFS_TRANS_SB_IMAXPCT 0x00000100 |
| 203 | #define XFS_TRANS_SB_REXTSIZE 0x00000200 |
| 204 | #define XFS_TRANS_SB_RBMBLOCKS 0x00000400 |
| 205 | #define XFS_TRANS_SB_RBLOCKS 0x00000800 |
| 206 | #define XFS_TRANS_SB_REXTENTS 0x00001000 |
| 207 | #define XFS_TRANS_SB_REXTSLOG 0x00002000 |
| 208 | |
| 209 | |
| 210 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | * Per-extent log reservation for the allocation btree changes |
| 212 | * involved in freeing or allocating an extent. |
| 213 | * 2 trees * (2 blocks/level * max depth - 1) * block size |
| 214 | */ |
| 215 | #define XFS_ALLOCFREE_LOG_RES(mp,nx) \ |
| 216 | ((nx) * (2 * XFS_FSB_TO_B((mp), 2 * XFS_AG_MAXLEVELS(mp) - 1))) |
| 217 | #define XFS_ALLOCFREE_LOG_COUNT(mp,nx) \ |
| 218 | ((nx) * (2 * (2 * XFS_AG_MAXLEVELS(mp) - 1))) |
| 219 | |
| 220 | /* |
| 221 | * Per-directory log reservation for any directory change. |
| 222 | * dir blocks: (1 btree block per level + data block + free block) * dblock size |
| 223 | * bmap btree: (levels + 2) * max depth * block size |
| 224 | * v2 directory blocks can be fragmented below the dirblksize down to the fsb |
| 225 | * size, so account for that in the DAENTER macros. |
| 226 | */ |
| 227 | #define XFS_DIROP_LOG_RES(mp) \ |
| 228 | (XFS_FSB_TO_B(mp, XFS_DAENTER_BLOCKS(mp, XFS_DATA_FORK)) + \ |
| 229 | (XFS_FSB_TO_B(mp, XFS_DAENTER_BMAPS(mp, XFS_DATA_FORK) + 1))) |
| 230 | #define XFS_DIROP_LOG_COUNT(mp) \ |
| 231 | (XFS_DAENTER_BLOCKS(mp, XFS_DATA_FORK) + \ |
| 232 | XFS_DAENTER_BMAPS(mp, XFS_DATA_FORK) + 1) |
| 233 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | |
| 235 | #define XFS_WRITE_LOG_RES(mp) ((mp)->m_reservations.tr_write) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | #define XFS_ITRUNCATE_LOG_RES(mp) ((mp)->m_reservations.tr_itruncate) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | #define XFS_RENAME_LOG_RES(mp) ((mp)->m_reservations.tr_rename) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | #define XFS_LINK_LOG_RES(mp) ((mp)->m_reservations.tr_link) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | #define XFS_REMOVE_LOG_RES(mp) ((mp)->m_reservations.tr_remove) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | #define XFS_SYMLINK_LOG_RES(mp) ((mp)->m_reservations.tr_symlink) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | #define XFS_CREATE_LOG_RES(mp) ((mp)->m_reservations.tr_create) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | #define XFS_MKDIR_LOG_RES(mp) ((mp)->m_reservations.tr_mkdir) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | #define XFS_IFREE_LOG_RES(mp) ((mp)->m_reservations.tr_ifree) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | #define XFS_ICHANGE_LOG_RES(mp) ((mp)->m_reservations.tr_ichange) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | #define XFS_GROWDATA_LOG_RES(mp) ((mp)->m_reservations.tr_growdata) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | #define XFS_GROWRTALLOC_LOG_RES(mp) ((mp)->m_reservations.tr_growrtalloc) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | #define XFS_GROWRTZERO_LOG_RES(mp) ((mp)->m_reservations.tr_growrtzero) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | #define XFS_GROWRTFREE_LOG_RES(mp) ((mp)->m_reservations.tr_growrtfree) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | #define XFS_SWRITE_LOG_RES(mp) ((mp)->m_reservations.tr_swrite) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 250 | /* |
| 251 | * Logging the inode timestamps on an fsync -- same as SWRITE |
| 252 | * as long as SWRITE logs the entire inode core |
| 253 | */ |
| 254 | #define XFS_FSYNC_TS_LOG_RES(mp) ((mp)->m_reservations.tr_swrite) |
Jeff Liu | a21cd50 | 2013-01-28 21:27:53 +0800 | [diff] [blame] | 255 | #define XFS_WRITEID_LOG_RES(mp) ((mp)->m_reservations.tr_swrite) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | #define XFS_ADDAFORK_LOG_RES(mp) ((mp)->m_reservations.tr_addafork) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | #define XFS_ATTRINVAL_LOG_RES(mp) ((mp)->m_reservations.tr_attrinval) |
Jeff Liu | a21cd50 | 2013-01-28 21:27:53 +0800 | [diff] [blame] | 258 | #define XFS_ATTRSETM_LOG_RES(mp) ((mp)->m_reservations.tr_attrsetm) |
| 259 | #define XFS_ATTRSETRT_LOG_RES(mp) ((mp)->m_reservations.tr_attrsetrt) |
| 260 | #define XFS_ATTRRM_LOG_RES(mp) ((mp)->m_reservations.tr_attrrm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 261 | #define XFS_CLEAR_AGI_BUCKET_LOG_RES(mp) ((mp)->m_reservations.tr_clearagi) |
Jeff Liu | b0c10b98 | 2013-01-28 21:26:16 +0800 | [diff] [blame] | 262 | #define XFS_QM_SBCHANGE_LOG_RES(mp) ((mp)->m_reservations.tr_qm_sbchange) |
Jeff Liu | f0f2df9 | 2013-01-28 21:26:49 +0800 | [diff] [blame] | 263 | #define XFS_QM_SETQLIM_LOG_RES(mp) ((mp)->m_reservations.tr_qm_setqlim) |
Jeff Liu | 4800104 | 2013-01-28 21:27:04 +0800 | [diff] [blame] | 264 | #define XFS_QM_DQALLOC_LOG_RES(mp) ((mp)->m_reservations.tr_qm_dqalloc) |
Jeff Liu | a1bd955 | 2013-01-28 21:27:15 +0800 | [diff] [blame] | 265 | #define XFS_QM_QUOTAOFF_LOG_RES(mp) ((mp)->m_reservations.tr_qm_quotaoff) |
Jeff Liu | 762d7ba | 2013-01-28 21:27:21 +0800 | [diff] [blame] | 266 | #define XFS_QM_QUOTAOFF_END_LOG_RES(mp) ((mp)->m_reservations.tr_qm_equotaoff) |
Jeff Liu | a7bd794 | 2013-01-28 21:27:25 +0800 | [diff] [blame] | 267 | #define XFS_SB_LOG_RES(mp) ((mp)->m_reservations.tr_sb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | |
| 269 | /* |
| 270 | * Various log count values. |
| 271 | */ |
| 272 | #define XFS_DEFAULT_LOG_COUNT 1 |
| 273 | #define XFS_DEFAULT_PERM_LOG_COUNT 2 |
| 274 | #define XFS_ITRUNCATE_LOG_COUNT 2 |
| 275 | #define XFS_INACTIVE_LOG_COUNT 2 |
| 276 | #define XFS_CREATE_LOG_COUNT 2 |
| 277 | #define XFS_MKDIR_LOG_COUNT 3 |
| 278 | #define XFS_SYMLINK_LOG_COUNT 3 |
| 279 | #define XFS_REMOVE_LOG_COUNT 2 |
| 280 | #define XFS_LINK_LOG_COUNT 2 |
| 281 | #define XFS_RENAME_LOG_COUNT 2 |
| 282 | #define XFS_WRITE_LOG_COUNT 2 |
| 283 | #define XFS_ADDAFORK_LOG_COUNT 2 |
| 284 | #define XFS_ATTRINVAL_LOG_COUNT 1 |
| 285 | #define XFS_ATTRSET_LOG_COUNT 3 |
| 286 | #define XFS_ATTRRM_LOG_COUNT 3 |
| 287 | |
| 288 | /* |
| 289 | * Here we centralize the specification of XFS meta-data buffer |
| 290 | * reference count values. This determine how hard the buffer |
| 291 | * cache tries to hold onto the buffer. |
| 292 | */ |
| 293 | #define XFS_AGF_REF 4 |
| 294 | #define XFS_AGI_REF 4 |
| 295 | #define XFS_AGFL_REF 3 |
| 296 | #define XFS_INO_BTREE_REF 3 |
| 297 | #define XFS_ALLOC_BTREE_REF 2 |
| 298 | #define XFS_BMAP_BTREE_REF 2 |
| 299 | #define XFS_DIR_BTREE_REF 2 |
Dave Chinner | 821eb21 | 2010-12-02 16:31:13 +1100 | [diff] [blame] | 300 | #define XFS_INO_REF 2 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | #define XFS_ATTR_BTREE_REF 1 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | #define XFS_DQUOT_REF 1 |
| 303 | |
| 304 | #ifdef __KERNEL__ |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 305 | |
| 306 | struct xfs_buf; |
| 307 | struct xfs_buftarg; |
| 308 | struct xfs_efd_log_item; |
| 309 | struct xfs_efi_log_item; |
| 310 | struct xfs_inode; |
| 311 | struct xfs_item_ops; |
| 312 | struct xfs_log_iovec; |
| 313 | struct xfs_log_item_desc; |
| 314 | struct xfs_mount; |
| 315 | struct xfs_trans; |
| 316 | struct xfs_dquot_acct; |
Dave Chinner | ed3b4d6 | 2010-05-21 12:07:08 +1000 | [diff] [blame] | 317 | struct xfs_busy_extent; |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 318 | |
| 319 | typedef struct xfs_log_item { |
| 320 | struct list_head li_ail; /* AIL pointers */ |
| 321 | xfs_lsn_t li_lsn; /* last on-disk lsn */ |
| 322 | struct xfs_log_item_desc *li_desc; /* ptr to current desc*/ |
| 323 | struct xfs_mount *li_mountp; /* ptr to fs mount */ |
David Chinner | fc1829f | 2008-10-30 17:39:46 +1100 | [diff] [blame] | 324 | struct xfs_ail *li_ailp; /* ptr to AIL */ |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 325 | uint li_type; /* item type */ |
| 326 | uint li_flags; /* misc flags */ |
| 327 | struct xfs_log_item *li_bio_list; /* buffer item list */ |
| 328 | void (*li_cb)(struct xfs_buf *, |
| 329 | struct xfs_log_item *); |
| 330 | /* buffer item iodone */ |
| 331 | /* callback func */ |
Christoph Hellwig | 272e42b | 2011-10-28 09:54:24 +0000 | [diff] [blame] | 332 | const struct xfs_item_ops *li_ops; /* function list */ |
Dave Chinner | 71e330b | 2010-05-21 14:37:18 +1000 | [diff] [blame] | 333 | |
| 334 | /* delayed logging */ |
| 335 | struct list_head li_cil; /* CIL pointers */ |
| 336 | struct xfs_log_vec *li_lv; /* active log vector */ |
Dave Chinner | ccf7c23 | 2010-05-20 23:19:42 +1000 | [diff] [blame] | 337 | xfs_lsn_t li_seq; /* CIL commit seq */ |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 338 | } xfs_log_item_t; |
| 339 | |
| 340 | #define XFS_LI_IN_AIL 0x1 |
| 341 | #define XFS_LI_ABORTED 0x2 |
| 342 | |
Christoph Hellwig | 0b1b213 | 2009-12-14 23:14:59 +0000 | [diff] [blame] | 343 | #define XFS_LI_FLAGS \ |
| 344 | { XFS_LI_IN_AIL, "IN_AIL" }, \ |
| 345 | { XFS_LI_ABORTED, "ABORTED" } |
| 346 | |
Christoph Hellwig | 272e42b | 2011-10-28 09:54:24 +0000 | [diff] [blame] | 347 | struct xfs_item_ops { |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 348 | uint (*iop_size)(xfs_log_item_t *); |
| 349 | void (*iop_format)(xfs_log_item_t *, struct xfs_log_iovec *); |
| 350 | void (*iop_pin)(xfs_log_item_t *); |
Christoph Hellwig | 9412e31 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 351 | void (*iop_unpin)(xfs_log_item_t *, int remove); |
Christoph Hellwig | 43ff212 | 2012-04-23 15:58:39 +1000 | [diff] [blame] | 352 | uint (*iop_push)(struct xfs_log_item *, struct list_head *); |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 353 | void (*iop_unlock)(xfs_log_item_t *); |
| 354 | xfs_lsn_t (*iop_committed)(xfs_log_item_t *, xfs_lsn_t); |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 355 | void (*iop_committing)(xfs_log_item_t *, xfs_lsn_t); |
Christoph Hellwig | 272e42b | 2011-10-28 09:54:24 +0000 | [diff] [blame] | 356 | }; |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 357 | |
| 358 | #define IOP_SIZE(ip) (*(ip)->li_ops->iop_size)(ip) |
| 359 | #define IOP_FORMAT(ip,vp) (*(ip)->li_ops->iop_format)(ip, vp) |
| 360 | #define IOP_PIN(ip) (*(ip)->li_ops->iop_pin)(ip) |
Christoph Hellwig | 9412e31 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 361 | #define IOP_UNPIN(ip, remove) (*(ip)->li_ops->iop_unpin)(ip, remove) |
Christoph Hellwig | 43ff212 | 2012-04-23 15:58:39 +1000 | [diff] [blame] | 362 | #define IOP_PUSH(ip, list) (*(ip)->li_ops->iop_push)(ip, list) |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 363 | #define IOP_UNLOCK(ip) (*(ip)->li_ops->iop_unlock)(ip) |
| 364 | #define IOP_COMMITTED(ip, lsn) (*(ip)->li_ops->iop_committed)(ip, lsn) |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 365 | #define IOP_COMMITTING(ip, lsn) (*(ip)->li_ops->iop_committing)(ip, lsn) |
| 366 | |
| 367 | /* |
Christoph Hellwig | 43ff212 | 2012-04-23 15:58:39 +1000 | [diff] [blame] | 368 | * Return values for the IOP_PUSH() routines. |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 369 | */ |
Christoph Hellwig | 43ff212 | 2012-04-23 15:58:39 +1000 | [diff] [blame] | 370 | #define XFS_ITEM_SUCCESS 0 |
| 371 | #define XFS_ITEM_PINNED 1 |
| 372 | #define XFS_ITEM_LOCKED 2 |
| 373 | #define XFS_ITEM_FLUSHING 3 |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 374 | |
| 375 | /* |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 376 | * This is the type of function which can be given to xfs_trans_callback() |
| 377 | * to be called upon the transaction's commit to disk. |
| 378 | */ |
| 379 | typedef void (*xfs_trans_callback_t)(struct xfs_trans *, void *); |
| 380 | |
| 381 | /* |
| 382 | * This is the structure maintained for every active transaction. |
| 383 | */ |
| 384 | typedef struct xfs_trans { |
| 385 | unsigned int t_magic; /* magic number */ |
| 386 | xfs_log_callback_t t_logcb; /* log callback struct */ |
| 387 | unsigned int t_type; /* transaction type */ |
| 388 | unsigned int t_log_res; /* amt of log space resvd */ |
| 389 | unsigned int t_log_count; /* count for perm log res */ |
| 390 | unsigned int t_blk_res; /* # of blocks resvd */ |
| 391 | unsigned int t_blk_res_used; /* # of resvd blocks used */ |
| 392 | unsigned int t_rtx_res; /* # of rt extents resvd */ |
| 393 | unsigned int t_rtx_res_used; /* # of resvd rt extents used */ |
Christoph Hellwig | 35a8a72 | 2010-02-15 23:34:54 +0000 | [diff] [blame] | 394 | struct xlog_ticket *t_ticket; /* log mgr ticket */ |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 395 | xfs_lsn_t t_lsn; /* log seq num of start of |
| 396 | * transaction. */ |
| 397 | xfs_lsn_t t_commit_lsn; /* log seq num of end of |
| 398 | * transaction. */ |
| 399 | struct xfs_mount *t_mountp; /* ptr to fs mount struct */ |
| 400 | struct xfs_dquot_acct *t_dqinfo; /* acctg info for dquots */ |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 401 | unsigned int t_flags; /* misc flags */ |
| 402 | int64_t t_icount_delta; /* superblock icount change */ |
| 403 | int64_t t_ifree_delta; /* superblock ifree change */ |
| 404 | int64_t t_fdblocks_delta; /* superblock fdblocks chg */ |
| 405 | int64_t t_res_fdblocks_delta; /* on-disk only chg */ |
| 406 | int64_t t_frextents_delta;/* superblock freextents chg*/ |
| 407 | int64_t t_res_frextents_delta; /* on-disk only chg */ |
| 408 | #ifdef DEBUG |
| 409 | int64_t t_ag_freeblks_delta; /* debugging counter */ |
| 410 | int64_t t_ag_flist_delta; /* debugging counter */ |
| 411 | int64_t t_ag_btree_delta; /* debugging counter */ |
| 412 | #endif |
| 413 | int64_t t_dblocks_delta;/* superblock dblocks change */ |
| 414 | int64_t t_agcount_delta;/* superblock agcount change */ |
| 415 | int64_t t_imaxpct_delta;/* superblock imaxpct change */ |
| 416 | int64_t t_rextsize_delta;/* superblock rextsize chg */ |
| 417 | int64_t t_rbmblocks_delta;/* superblock rbmblocks chg */ |
| 418 | int64_t t_rblocks_delta;/* superblock rblocks change */ |
| 419 | int64_t t_rextents_delta;/* superblocks rextents chg */ |
| 420 | int64_t t_rextslog_delta;/* superblocks rextslog chg */ |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 421 | struct list_head t_items; /* log item descriptors */ |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 422 | xfs_trans_header_t t_header; /* header for in-log trans */ |
Dave Chinner | ed3b4d6 | 2010-05-21 12:07:08 +1000 | [diff] [blame] | 423 | struct list_head t_busy; /* list of busy extents */ |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 424 | unsigned long t_pflags; /* saved process flags state */ |
| 425 | } xfs_trans_t; |
| 426 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 427 | /* |
| 428 | * XFS transaction mechanism exported interfaces that are |
| 429 | * actually macros. |
| 430 | */ |
| 431 | #define xfs_trans_get_log_res(tp) ((tp)->t_log_res) |
| 432 | #define xfs_trans_get_log_count(tp) ((tp)->t_log_count) |
| 433 | #define xfs_trans_get_block_res(tp) ((tp)->t_blk_res) |
| 434 | #define xfs_trans_set_sync(tp) ((tp)->t_flags |= XFS_TRANS_SYNC) |
| 435 | |
| 436 | #ifdef DEBUG |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 437 | #define xfs_trans_agblocks_delta(tp, d) ((tp)->t_ag_freeblks_delta += (int64_t)d) |
| 438 | #define xfs_trans_agflist_delta(tp, d) ((tp)->t_ag_flist_delta += (int64_t)d) |
| 439 | #define xfs_trans_agbtree_delta(tp, d) ((tp)->t_ag_btree_delta += (int64_t)d) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 440 | #else |
| 441 | #define xfs_trans_agblocks_delta(tp, d) |
| 442 | #define xfs_trans_agflist_delta(tp, d) |
| 443 | #define xfs_trans_agbtree_delta(tp, d) |
| 444 | #endif |
| 445 | |
| 446 | /* |
| 447 | * XFS transaction mechanism exported interfaces. |
| 448 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | xfs_trans_t *xfs_trans_alloc(struct xfs_mount *, uint); |
Al Viro | 77ba787 | 2012-04-02 06:24:04 -0400 | [diff] [blame] | 450 | xfs_trans_t *_xfs_trans_alloc(struct xfs_mount *, uint, xfs_km_flags_t); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | xfs_trans_t *xfs_trans_dup(xfs_trans_t *); |
| 452 | int xfs_trans_reserve(xfs_trans_t *, uint, uint, uint, |
| 453 | uint, uint); |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 454 | void xfs_trans_mod_sb(xfs_trans_t *, uint, int64_t); |
Dave Chinner | de2a4f5 | 2012-06-22 18:50:11 +1000 | [diff] [blame] | 455 | |
| 456 | struct xfs_buf *xfs_trans_get_buf_map(struct xfs_trans *tp, |
| 457 | struct xfs_buftarg *target, |
| 458 | struct xfs_buf_map *map, int nmaps, |
| 459 | uint flags); |
| 460 | |
| 461 | static inline struct xfs_buf * |
| 462 | xfs_trans_get_buf( |
| 463 | struct xfs_trans *tp, |
| 464 | struct xfs_buftarg *target, |
| 465 | xfs_daddr_t blkno, |
| 466 | int numblks, |
| 467 | uint flags) |
| 468 | { |
Dave Chinner | c3f8fc7 | 2012-11-12 22:54:01 +1100 | [diff] [blame] | 469 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); |
Dave Chinner | de2a4f5 | 2012-06-22 18:50:11 +1000 | [diff] [blame] | 470 | return xfs_trans_get_buf_map(tp, target, &map, 1, flags); |
| 471 | } |
| 472 | |
| 473 | int xfs_trans_read_buf_map(struct xfs_mount *mp, |
| 474 | struct xfs_trans *tp, |
| 475 | struct xfs_buftarg *target, |
| 476 | struct xfs_buf_map *map, int nmaps, |
| 477 | xfs_buf_flags_t flags, |
Dave Chinner | c3f8fc7 | 2012-11-12 22:54:01 +1100 | [diff] [blame] | 478 | struct xfs_buf **bpp, |
Dave Chinner | 1813dd6 | 2012-11-14 17:54:40 +1100 | [diff] [blame] | 479 | const struct xfs_buf_ops *ops); |
Dave Chinner | de2a4f5 | 2012-06-22 18:50:11 +1000 | [diff] [blame] | 480 | |
| 481 | static inline int |
| 482 | xfs_trans_read_buf( |
| 483 | struct xfs_mount *mp, |
| 484 | struct xfs_trans *tp, |
| 485 | struct xfs_buftarg *target, |
| 486 | xfs_daddr_t blkno, |
| 487 | int numblks, |
| 488 | xfs_buf_flags_t flags, |
Dave Chinner | c3f8fc7 | 2012-11-12 22:54:01 +1100 | [diff] [blame] | 489 | struct xfs_buf **bpp, |
Dave Chinner | 1813dd6 | 2012-11-14 17:54:40 +1100 | [diff] [blame] | 490 | const struct xfs_buf_ops *ops) |
Dave Chinner | de2a4f5 | 2012-06-22 18:50:11 +1000 | [diff] [blame] | 491 | { |
Dave Chinner | c3f8fc7 | 2012-11-12 22:54:01 +1100 | [diff] [blame] | 492 | DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); |
| 493 | return xfs_trans_read_buf_map(mp, tp, target, &map, 1, |
Dave Chinner | 1813dd6 | 2012-11-14 17:54:40 +1100 | [diff] [blame] | 494 | flags, bpp, ops); |
Dave Chinner | de2a4f5 | 2012-06-22 18:50:11 +1000 | [diff] [blame] | 495 | } |
| 496 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | struct xfs_buf *xfs_trans_getsb(xfs_trans_t *, struct xfs_mount *, int); |
| 498 | |
| 499 | void xfs_trans_brelse(xfs_trans_t *, struct xfs_buf *); |
| 500 | void xfs_trans_bjoin(xfs_trans_t *, struct xfs_buf *); |
| 501 | void xfs_trans_bhold(xfs_trans_t *, struct xfs_buf *); |
Tim Shimmin | efa092f | 2005-09-05 08:29:01 +1000 | [diff] [blame] | 502 | void xfs_trans_bhold_release(xfs_trans_t *, struct xfs_buf *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | void xfs_trans_binval(xfs_trans_t *, struct xfs_buf *); |
| 504 | void xfs_trans_inode_buf(xfs_trans_t *, struct xfs_buf *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 505 | void xfs_trans_stale_inode_buf(xfs_trans_t *, struct xfs_buf *); |
| 506 | void xfs_trans_dquot_buf(xfs_trans_t *, struct xfs_buf *, uint); |
| 507 | void xfs_trans_inode_alloc_buf(xfs_trans_t *, struct xfs_buf *); |
Christoph Hellwig | ee1a47a | 2013-04-21 14:53:46 -0500 | [diff] [blame] | 508 | void xfs_trans_buf_set_type(struct xfs_trans *, struct xfs_buf *, |
| 509 | uint); |
Dave Chinner | dcd79a1 | 2010-09-28 12:27:25 +1000 | [diff] [blame] | 510 | void xfs_trans_ichgtime(struct xfs_trans *, struct xfs_inode *, int); |
Christoph Hellwig | ddc3415 | 2011-09-19 15:00:54 +0000 | [diff] [blame] | 511 | void xfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *, uint); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 512 | void xfs_trans_log_buf(xfs_trans_t *, struct xfs_buf *, uint, uint); |
| 513 | void xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint); |
| 514 | struct xfs_efi_log_item *xfs_trans_get_efi(xfs_trans_t *, uint); |
| 515 | void xfs_efi_release(struct xfs_efi_log_item *, uint); |
| 516 | void xfs_trans_log_efi_extent(xfs_trans_t *, |
| 517 | struct xfs_efi_log_item *, |
| 518 | xfs_fsblock_t, |
| 519 | xfs_extlen_t); |
| 520 | struct xfs_efd_log_item *xfs_trans_get_efd(xfs_trans_t *, |
| 521 | struct xfs_efi_log_item *, |
| 522 | uint); |
| 523 | void xfs_trans_log_efd_extent(xfs_trans_t *, |
| 524 | struct xfs_efd_log_item *, |
| 525 | xfs_fsblock_t, |
| 526 | xfs_extlen_t); |
Christoph Hellwig | b103705 | 2011-09-19 14:55:51 +0000 | [diff] [blame] | 527 | int xfs_trans_commit(xfs_trans_t *, uint flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 528 | void xfs_trans_cancel(xfs_trans_t *, int); |
David Chinner | 249a8c1 | 2008-02-05 12:13:32 +1100 | [diff] [blame] | 529 | int xfs_trans_ail_init(struct xfs_mount *); |
| 530 | void xfs_trans_ail_destroy(struct xfs_mount *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 531 | |
David Chinner | a8272ce | 2007-11-23 16:28:09 +1100 | [diff] [blame] | 532 | extern kmem_zone_t *xfs_trans_zone; |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 533 | extern kmem_zone_t *xfs_log_item_desc_zone; |
David Chinner | a8272ce | 2007-11-23 16:28:09 +1100 | [diff] [blame] | 534 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | #endif /* __KERNEL__ */ |
| 536 | |
Barry Naujok | 847fff5 | 2008-10-30 17:05:38 +1100 | [diff] [blame] | 537 | void xfs_trans_init(struct xfs_mount *); |
| 538 | int xfs_trans_roll(struct xfs_trans **, struct xfs_inode *); |
| 539 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 540 | #endif /* __XFS_TRANS_H__ */ |