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-2003,2005 Silicon Graphics, Inc. |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 3 | * Copyright (C) 2010 Red Hat, Inc. |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 4 | * All Rights Reserved. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License as |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | * published by the Free Software Foundation. |
| 9 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 10 | * This program is distributed in the hope that it would be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | * GNU General Public License for more details. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | * |
Nathan Scott | 7b71876 | 2005-11-02 14:58:39 +1100 | [diff] [blame] | 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program; if not, write the Free Software Foundation, |
| 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include "xfs.h" |
Nathan Scott | a844f45 | 2005-11-02 14:38:42 +1100 | [diff] [blame] | 20 | #include "xfs_fs.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | #include "xfs_types.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #include "xfs_log.h" |
| 23 | #include "xfs_trans.h" |
| 24 | #include "xfs_sb.h" |
| 25 | #include "xfs_ag.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include "xfs_mount.h" |
| 27 | #include "xfs_error.h" |
Nathan Scott | a844f45 | 2005-11-02 14:38:42 +1100 | [diff] [blame] | 28 | #include "xfs_da_btree.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include "xfs_bmap_btree.h" |
Nathan Scott | a844f45 | 2005-11-02 14:38:42 +1100 | [diff] [blame] | 30 | #include "xfs_alloc_btree.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include "xfs_ialloc_btree.h" |
Nathan Scott | a844f45 | 2005-11-02 14:38:42 +1100 | [diff] [blame] | 32 | #include "xfs_dinode.h" |
| 33 | #include "xfs_inode.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #include "xfs_btree.h" |
| 35 | #include "xfs_ialloc.h" |
| 36 | #include "xfs_alloc.h" |
Dave Chinner | efc27b5 | 2012-04-29 10:39:43 +0000 | [diff] [blame] | 37 | #include "xfs_extent_busy.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | #include "xfs_bmap.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | #include "xfs_quota.h" |
Nathan Scott | a844f45 | 2005-11-02 14:38:42 +1100 | [diff] [blame] | 40 | #include "xfs_trans_priv.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | #include "xfs_trans_space.h" |
Niv Sardi | 322ff6b | 2008-08-13 16:05:49 +1000 | [diff] [blame] | 42 | #include "xfs_inode_item.h" |
Dave Chinner | ed3b4d6 | 2010-05-21 12:07:08 +1000 | [diff] [blame] | 43 | #include "xfs_trace.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 45 | kmem_zone_t *xfs_trans_zone; |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 46 | kmem_zone_t *xfs_log_item_desc_zone; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 48 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | /* |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 50 | * Various log reservation values. |
| 51 | * |
| 52 | * These are based on the size of the file system block because that is what |
| 53 | * most transactions manipulate. Each adds in an additional 128 bytes per |
| 54 | * item logged to try to account for the overhead of the transaction mechanism. |
| 55 | * |
| 56 | * Note: Most of the reservations underestimate the number of allocation |
| 57 | * groups into which they could free extents in the xfs_bmap_finish() call. |
| 58 | * This is because the number in the worst case is quite high and quite |
| 59 | * unusual. In order to fix this we need to change xfs_bmap_finish() to free |
| 60 | * extents in only a single AG at a time. This will require changes to the |
| 61 | * EFI code as well, however, so that the EFI for the extents not freed is |
| 62 | * logged again in each transaction. See SGI PV #261917. |
| 63 | * |
| 64 | * Reservation functions here avoid a huge stack in xfs_trans_init due to |
| 65 | * register overflow from temporaries in the calculations. |
| 66 | */ |
| 67 | |
| 68 | |
| 69 | /* |
| 70 | * In a write transaction we can allocate a maximum of 2 |
| 71 | * extents. This gives: |
| 72 | * the inode getting the new extents: inode size |
| 73 | * the inode's bmap btree: max depth * block size |
| 74 | * the agfs of the ags from which the extents are allocated: 2 * sector |
| 75 | * the superblock free block counter: sector size |
| 76 | * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size |
| 77 | * And the bmap_finish transaction can free bmap blocks in a join: |
| 78 | * the agfs of the ags containing the blocks: 2 * sector size |
| 79 | * the agfls of the ags containing the blocks: 2 * sector size |
| 80 | * the super block free block counter: sector size |
| 81 | * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 82 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 83 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 84 | xfs_calc_write_reservation( |
| 85 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 86 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 87 | return XFS_DQUOT_LOGRES(mp) + |
| 88 | MAX((mp->m_sb.sb_inodesize + |
| 89 | XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) + |
| 90 | 2 * mp->m_sb.sb_sectsize + |
| 91 | mp->m_sb.sb_sectsize + |
| 92 | XFS_ALLOCFREE_LOG_RES(mp, 2) + |
| 93 | 128 * (4 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + |
| 94 | XFS_ALLOCFREE_LOG_COUNT(mp, 2))), |
| 95 | (2 * mp->m_sb.sb_sectsize + |
| 96 | 2 * mp->m_sb.sb_sectsize + |
| 97 | mp->m_sb.sb_sectsize + |
| 98 | XFS_ALLOCFREE_LOG_RES(mp, 2) + |
| 99 | 128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 100 | } |
| 101 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 102 | /* |
| 103 | * In truncating a file we free up to two extents at once. We can modify: |
| 104 | * the inode being truncated: inode size |
| 105 | * the inode's bmap btree: (max depth + 1) * block size |
| 106 | * And the bmap_finish transaction can free the blocks and bmap blocks: |
| 107 | * the agf for each of the ags: 4 * sector size |
| 108 | * the agfl for each of the ags: 4 * sector size |
| 109 | * the super block to reflect the freed blocks: sector size |
| 110 | * worst case split in allocation btrees per extent assuming 4 extents: |
| 111 | * 4 exts * 2 trees * (2 * max depth - 1) * block size |
| 112 | * the inode btree: max depth * blocksize |
| 113 | * the allocation btrees: 2 trees * (max depth - 1) * block size |
| 114 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 115 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 116 | xfs_calc_itruncate_reservation( |
| 117 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 118 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 119 | return XFS_DQUOT_LOGRES(mp) + |
| 120 | MAX((mp->m_sb.sb_inodesize + |
| 121 | XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1) + |
| 122 | 128 * (2 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))), |
| 123 | (4 * mp->m_sb.sb_sectsize + |
| 124 | 4 * mp->m_sb.sb_sectsize + |
| 125 | mp->m_sb.sb_sectsize + |
| 126 | XFS_ALLOCFREE_LOG_RES(mp, 4) + |
| 127 | 128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4)) + |
| 128 | 128 * 5 + |
| 129 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 130 | 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + |
| 131 | XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 132 | } |
| 133 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 134 | /* |
| 135 | * In renaming a files we can modify: |
| 136 | * the four inodes involved: 4 * inode size |
| 137 | * the two directory btrees: 2 * (max depth + v2) * dir block size |
| 138 | * the two directory bmap btrees: 2 * max depth * block size |
| 139 | * And the bmap_finish transaction can free dir and bmap blocks (two sets |
| 140 | * of bmap blocks) giving: |
| 141 | * the agf for the ags in which the blocks live: 3 * sector size |
| 142 | * the agfl for the ags in which the blocks live: 3 * sector size |
| 143 | * the superblock for the free block count: sector size |
| 144 | * the allocation btrees: 3 exts * 2 trees * (2 * max depth - 1) * block size |
| 145 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 146 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 147 | xfs_calc_rename_reservation( |
| 148 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 149 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 150 | return XFS_DQUOT_LOGRES(mp) + |
| 151 | MAX((4 * mp->m_sb.sb_inodesize + |
| 152 | 2 * XFS_DIROP_LOG_RES(mp) + |
| 153 | 128 * (4 + 2 * XFS_DIROP_LOG_COUNT(mp))), |
| 154 | (3 * mp->m_sb.sb_sectsize + |
| 155 | 3 * mp->m_sb.sb_sectsize + |
| 156 | mp->m_sb.sb_sectsize + |
| 157 | XFS_ALLOCFREE_LOG_RES(mp, 3) + |
| 158 | 128 * (7 + XFS_ALLOCFREE_LOG_COUNT(mp, 3)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 159 | } |
| 160 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 161 | /* |
| 162 | * For creating a link to an inode: |
| 163 | * the parent directory inode: inode size |
| 164 | * the linked inode: inode size |
| 165 | * the directory btree could split: (max depth + v2) * dir block size |
| 166 | * the directory bmap btree could join or split: (max depth + v2) * blocksize |
| 167 | * And the bmap_finish transaction can free some bmap blocks giving: |
| 168 | * the agf for the ag in which the blocks live: sector size |
| 169 | * the agfl for the ag in which the blocks live: sector size |
| 170 | * the superblock for the free block count: sector size |
| 171 | * the allocation btrees: 2 trees * (2 * max depth - 1) * block size |
| 172 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 173 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 174 | xfs_calc_link_reservation( |
| 175 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 176 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 177 | return XFS_DQUOT_LOGRES(mp) + |
| 178 | MAX((mp->m_sb.sb_inodesize + |
| 179 | mp->m_sb.sb_inodesize + |
| 180 | XFS_DIROP_LOG_RES(mp) + |
| 181 | 128 * (2 + XFS_DIROP_LOG_COUNT(mp))), |
| 182 | (mp->m_sb.sb_sectsize + |
| 183 | mp->m_sb.sb_sectsize + |
| 184 | mp->m_sb.sb_sectsize + |
| 185 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 186 | 128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 187 | } |
| 188 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 189 | /* |
| 190 | * For removing a directory entry we can modify: |
| 191 | * the parent directory inode: inode size |
| 192 | * the removed inode: inode size |
| 193 | * the directory btree could join: (max depth + v2) * dir block size |
| 194 | * the directory bmap btree could join or split: (max depth + v2) * blocksize |
| 195 | * And the bmap_finish transaction can free the dir and bmap blocks giving: |
| 196 | * the agf for the ag in which the blocks live: 2 * sector size |
| 197 | * the agfl for the ag in which the blocks live: 2 * sector size |
| 198 | * the superblock for the free block count: sector size |
| 199 | * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size |
| 200 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 201 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 202 | xfs_calc_remove_reservation( |
| 203 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 204 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 205 | return XFS_DQUOT_LOGRES(mp) + |
| 206 | MAX((mp->m_sb.sb_inodesize + |
| 207 | mp->m_sb.sb_inodesize + |
| 208 | XFS_DIROP_LOG_RES(mp) + |
| 209 | 128 * (2 + XFS_DIROP_LOG_COUNT(mp))), |
| 210 | (2 * mp->m_sb.sb_sectsize + |
| 211 | 2 * mp->m_sb.sb_sectsize + |
| 212 | mp->m_sb.sb_sectsize + |
| 213 | XFS_ALLOCFREE_LOG_RES(mp, 2) + |
| 214 | 128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 215 | } |
| 216 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 217 | /* |
| 218 | * For symlink we can modify: |
| 219 | * the parent directory inode: inode size |
| 220 | * the new inode: inode size |
| 221 | * the inode btree entry: 1 block |
| 222 | * the directory btree: (max depth + v2) * dir block size |
| 223 | * the directory inode's bmap btree: (max depth + v2) * block size |
| 224 | * the blocks for the symlink: 1 kB |
| 225 | * Or in the first xact we allocate some inodes giving: |
| 226 | * the agi and agf of the ag getting the new inodes: 2 * sectorsize |
| 227 | * the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize |
| 228 | * the inode btree: max depth * blocksize |
| 229 | * the allocation btrees: 2 trees * (2 * max depth - 1) * block size |
| 230 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 231 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 232 | xfs_calc_symlink_reservation( |
| 233 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 234 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 235 | return XFS_DQUOT_LOGRES(mp) + |
| 236 | MAX((mp->m_sb.sb_inodesize + |
| 237 | mp->m_sb.sb_inodesize + |
| 238 | XFS_FSB_TO_B(mp, 1) + |
| 239 | XFS_DIROP_LOG_RES(mp) + |
| 240 | 1024 + |
| 241 | 128 * (4 + XFS_DIROP_LOG_COUNT(mp))), |
| 242 | (2 * mp->m_sb.sb_sectsize + |
| 243 | XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) + |
| 244 | XFS_FSB_TO_B(mp, mp->m_in_maxlevels) + |
| 245 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 246 | 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + |
| 247 | XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 248 | } |
| 249 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 250 | /* |
| 251 | * For create we can modify: |
| 252 | * the parent directory inode: inode size |
| 253 | * the new inode: inode size |
| 254 | * the inode btree entry: block size |
| 255 | * the superblock for the nlink flag: sector size |
| 256 | * the directory btree: (max depth + v2) * dir block size |
| 257 | * the directory inode's bmap btree: (max depth + v2) * block size |
| 258 | * Or in the first xact we allocate some inodes giving: |
| 259 | * the agi and agf of the ag getting the new inodes: 2 * sectorsize |
| 260 | * the superblock for the nlink flag: sector size |
| 261 | * the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize |
| 262 | * the inode btree: max depth * blocksize |
| 263 | * the allocation btrees: 2 trees * (max depth - 1) * block size |
| 264 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 265 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 266 | xfs_calc_create_reservation( |
| 267 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 268 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 269 | return XFS_DQUOT_LOGRES(mp) + |
| 270 | MAX((mp->m_sb.sb_inodesize + |
| 271 | mp->m_sb.sb_inodesize + |
| 272 | mp->m_sb.sb_sectsize + |
| 273 | XFS_FSB_TO_B(mp, 1) + |
| 274 | XFS_DIROP_LOG_RES(mp) + |
| 275 | 128 * (3 + XFS_DIROP_LOG_COUNT(mp))), |
| 276 | (3 * mp->m_sb.sb_sectsize + |
| 277 | XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) + |
| 278 | XFS_FSB_TO_B(mp, mp->m_in_maxlevels) + |
| 279 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 280 | 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + |
| 281 | XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 282 | } |
| 283 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 284 | /* |
| 285 | * Making a new directory is the same as creating a new file. |
| 286 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 287 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 288 | xfs_calc_mkdir_reservation( |
| 289 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 290 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 291 | return xfs_calc_create_reservation(mp); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 292 | } |
| 293 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 294 | /* |
| 295 | * In freeing an inode we can modify: |
| 296 | * the inode being freed: inode size |
| 297 | * the super block free inode counter: sector size |
| 298 | * the agi hash list and counters: sector size |
| 299 | * the inode btree entry: block size |
| 300 | * the on disk inode before ours in the agi hash list: inode cluster size |
| 301 | * the inode btree: max depth * blocksize |
| 302 | * the allocation btrees: 2 trees * (max depth - 1) * block size |
| 303 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 304 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 305 | xfs_calc_ifree_reservation( |
| 306 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 307 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 308 | return XFS_DQUOT_LOGRES(mp) + |
| 309 | mp->m_sb.sb_inodesize + |
| 310 | mp->m_sb.sb_sectsize + |
| 311 | mp->m_sb.sb_sectsize + |
| 312 | XFS_FSB_TO_B(mp, 1) + |
| 313 | MAX((__uint16_t)XFS_FSB_TO_B(mp, 1), |
| 314 | XFS_INODE_CLUSTER_SIZE(mp)) + |
| 315 | 128 * 5 + |
| 316 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 317 | 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + |
| 318 | XFS_ALLOCFREE_LOG_COUNT(mp, 1)); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 319 | } |
| 320 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 321 | /* |
| 322 | * When only changing the inode we log the inode and possibly the superblock |
| 323 | * We also add a bit of slop for the transaction stuff. |
| 324 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 325 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 326 | xfs_calc_ichange_reservation( |
| 327 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 328 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 329 | return XFS_DQUOT_LOGRES(mp) + |
| 330 | mp->m_sb.sb_inodesize + |
| 331 | mp->m_sb.sb_sectsize + |
| 332 | 512; |
| 333 | |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 334 | } |
| 335 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 336 | /* |
| 337 | * Growing the data section of the filesystem. |
| 338 | * superblock |
| 339 | * agi and agf |
| 340 | * allocation btrees |
| 341 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 342 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 343 | xfs_calc_growdata_reservation( |
| 344 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 345 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 346 | return mp->m_sb.sb_sectsize * 3 + |
| 347 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 348 | 128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1)); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 349 | } |
| 350 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 351 | /* |
| 352 | * Growing the rt section of the filesystem. |
| 353 | * In the first set of transactions (ALLOC) we allocate space to the |
| 354 | * bitmap or summary files. |
| 355 | * superblock: sector size |
| 356 | * agf of the ag from which the extent is allocated: sector size |
| 357 | * bmap btree for bitmap/summary inode: max depth * blocksize |
| 358 | * bitmap/summary inode: inode size |
| 359 | * allocation btrees for 1 block alloc: 2 * (2 * maxdepth - 1) * blocksize |
| 360 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 361 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 362 | xfs_calc_growrtalloc_reservation( |
| 363 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 364 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 365 | return 2 * mp->m_sb.sb_sectsize + |
| 366 | XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) + |
| 367 | mp->m_sb.sb_inodesize + |
| 368 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 369 | 128 * (3 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + |
| 370 | XFS_ALLOCFREE_LOG_COUNT(mp, 1)); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 371 | } |
| 372 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 373 | /* |
| 374 | * Growing the rt section of the filesystem. |
| 375 | * In the second set of transactions (ZERO) we zero the new metadata blocks. |
| 376 | * one bitmap/summary block: blocksize |
| 377 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 378 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 379 | xfs_calc_growrtzero_reservation( |
| 380 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 381 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 382 | return mp->m_sb.sb_blocksize + 128; |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 383 | } |
| 384 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 385 | /* |
| 386 | * Growing the rt section of the filesystem. |
| 387 | * In the third set of transactions (FREE) we update metadata without |
| 388 | * allocating any new blocks. |
| 389 | * superblock: sector size |
| 390 | * bitmap inode: inode size |
| 391 | * summary inode: inode size |
| 392 | * one bitmap block: blocksize |
| 393 | * summary blocks: new summary size |
| 394 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 395 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 396 | xfs_calc_growrtfree_reservation( |
| 397 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 398 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 399 | return mp->m_sb.sb_sectsize + |
| 400 | 2 * mp->m_sb.sb_inodesize + |
| 401 | mp->m_sb.sb_blocksize + |
| 402 | mp->m_rsumsize + |
| 403 | 128 * 5; |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 404 | } |
| 405 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 406 | /* |
| 407 | * Logging the inode modification timestamp on a synchronous write. |
| 408 | * inode |
| 409 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 410 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 411 | xfs_calc_swrite_reservation( |
| 412 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 413 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 414 | return mp->m_sb.sb_inodesize + 128; |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 415 | } |
| 416 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 417 | /* |
| 418 | * Logging the inode mode bits when writing a setuid/setgid file |
| 419 | * inode |
| 420 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 421 | STATIC uint |
| 422 | xfs_calc_writeid_reservation(xfs_mount_t *mp) |
| 423 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 424 | return mp->m_sb.sb_inodesize + 128; |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 425 | } |
| 426 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 427 | /* |
| 428 | * Converting the inode from non-attributed to attributed. |
| 429 | * the inode being converted: inode size |
| 430 | * agf block and superblock (for block allocation) |
| 431 | * the new block (directory sized) |
| 432 | * bmap blocks for the new directory block |
| 433 | * allocation btrees |
| 434 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 435 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 436 | xfs_calc_addafork_reservation( |
| 437 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 438 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 439 | return XFS_DQUOT_LOGRES(mp) + |
| 440 | mp->m_sb.sb_inodesize + |
| 441 | mp->m_sb.sb_sectsize * 2 + |
| 442 | mp->m_dirblksize + |
| 443 | XFS_FSB_TO_B(mp, XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) + |
| 444 | XFS_ALLOCFREE_LOG_RES(mp, 1) + |
| 445 | 128 * (4 + XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1 + |
| 446 | XFS_ALLOCFREE_LOG_COUNT(mp, 1)); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 447 | } |
| 448 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 449 | /* |
| 450 | * Removing the attribute fork of a file |
| 451 | * the inode being truncated: inode size |
| 452 | * the inode's bmap btree: max depth * block size |
| 453 | * And the bmap_finish transaction can free the blocks and bmap blocks: |
| 454 | * the agf for each of the ags: 4 * sector size |
| 455 | * the agfl for each of the ags: 4 * sector size |
| 456 | * the super block to reflect the freed blocks: sector size |
| 457 | * worst case split in allocation btrees per extent assuming 4 extents: |
| 458 | * 4 exts * 2 trees * (2 * max depth - 1) * block size |
| 459 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 460 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 461 | xfs_calc_attrinval_reservation( |
| 462 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 463 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 464 | return MAX((mp->m_sb.sb_inodesize + |
| 465 | XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) + |
| 466 | 128 * (1 + XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK))), |
| 467 | (4 * mp->m_sb.sb_sectsize + |
| 468 | 4 * mp->m_sb.sb_sectsize + |
| 469 | mp->m_sb.sb_sectsize + |
| 470 | XFS_ALLOCFREE_LOG_RES(mp, 4) + |
| 471 | 128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 472 | } |
| 473 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 474 | /* |
| 475 | * Setting an attribute. |
| 476 | * the inode getting the attribute |
| 477 | * the superblock for allocations |
| 478 | * the agfs extents are allocated from |
| 479 | * the attribute btree * max depth |
| 480 | * the inode allocation btree |
| 481 | * Since attribute transaction space is dependent on the size of the attribute, |
| 482 | * the calculation is done partially at mount time and partially at runtime. |
| 483 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 484 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 485 | xfs_calc_attrset_reservation( |
| 486 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 487 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 488 | return XFS_DQUOT_LOGRES(mp) + |
| 489 | mp->m_sb.sb_inodesize + |
| 490 | mp->m_sb.sb_sectsize + |
| 491 | XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) + |
| 492 | 128 * (2 + XFS_DA_NODE_MAXDEPTH); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 493 | } |
| 494 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 495 | /* |
| 496 | * Removing an attribute. |
| 497 | * the inode: inode size |
| 498 | * the attribute btree could join: max depth * block size |
| 499 | * the inode bmap btree could join or split: max depth * block size |
| 500 | * And the bmap_finish transaction can free the attr blocks freed giving: |
| 501 | * the agf for the ag in which the blocks live: 2 * sector size |
| 502 | * the agfl for the ag in which the blocks live: 2 * sector size |
| 503 | * the superblock for the free block count: sector size |
| 504 | * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size |
| 505 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 506 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 507 | xfs_calc_attrrm_reservation( |
| 508 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 509 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 510 | return XFS_DQUOT_LOGRES(mp) + |
| 511 | MAX((mp->m_sb.sb_inodesize + |
| 512 | XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) + |
| 513 | XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) + |
| 514 | 128 * (1 + XFS_DA_NODE_MAXDEPTH + |
| 515 | XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))), |
| 516 | (2 * mp->m_sb.sb_sectsize + |
| 517 | 2 * mp->m_sb.sb_sectsize + |
| 518 | mp->m_sb.sb_sectsize + |
| 519 | XFS_ALLOCFREE_LOG_RES(mp, 2) + |
| 520 | 128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2)))); |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 521 | } |
| 522 | |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 523 | /* |
| 524 | * Clearing a bad agino number in an agi hash bucket. |
| 525 | */ |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 526 | STATIC uint |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 527 | xfs_calc_clear_agi_bucket_reservation( |
| 528 | struct xfs_mount *mp) |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 529 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 530 | return mp->m_sb.sb_sectsize + 128; |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 531 | } |
| 532 | |
| 533 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 534 | * Initialize the precomputed transaction reservation values |
| 535 | * in the mount structure. |
| 536 | */ |
| 537 | void |
| 538 | xfs_trans_init( |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 539 | struct xfs_mount *mp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 540 | { |
Christoph Hellwig | 025101d | 2010-05-04 13:53:48 +0000 | [diff] [blame] | 541 | struct xfs_trans_reservations *resp = &mp->m_reservations; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 542 | |
Nathan Scott | 8f79405 | 2006-03-14 13:32:41 +1100 | [diff] [blame] | 543 | resp->tr_write = xfs_calc_write_reservation(mp); |
| 544 | resp->tr_itruncate = xfs_calc_itruncate_reservation(mp); |
| 545 | resp->tr_rename = xfs_calc_rename_reservation(mp); |
| 546 | resp->tr_link = xfs_calc_link_reservation(mp); |
| 547 | resp->tr_remove = xfs_calc_remove_reservation(mp); |
| 548 | resp->tr_symlink = xfs_calc_symlink_reservation(mp); |
| 549 | resp->tr_create = xfs_calc_create_reservation(mp); |
| 550 | resp->tr_mkdir = xfs_calc_mkdir_reservation(mp); |
| 551 | resp->tr_ifree = xfs_calc_ifree_reservation(mp); |
| 552 | resp->tr_ichange = xfs_calc_ichange_reservation(mp); |
| 553 | resp->tr_growdata = xfs_calc_growdata_reservation(mp); |
| 554 | resp->tr_swrite = xfs_calc_swrite_reservation(mp); |
| 555 | resp->tr_writeid = xfs_calc_writeid_reservation(mp); |
| 556 | resp->tr_addafork = xfs_calc_addafork_reservation(mp); |
| 557 | resp->tr_attrinval = xfs_calc_attrinval_reservation(mp); |
| 558 | resp->tr_attrset = xfs_calc_attrset_reservation(mp); |
| 559 | resp->tr_attrrm = xfs_calc_attrrm_reservation(mp); |
| 560 | resp->tr_clearagi = xfs_calc_clear_agi_bucket_reservation(mp); |
| 561 | resp->tr_growrtalloc = xfs_calc_growrtalloc_reservation(mp); |
| 562 | resp->tr_growrtzero = xfs_calc_growrtzero_reservation(mp); |
| 563 | resp->tr_growrtfree = xfs_calc_growrtfree_reservation(mp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 564 | } |
| 565 | |
| 566 | /* |
| 567 | * This routine is called to allocate a transaction structure. |
| 568 | * The type parameter indicates the type of the transaction. These |
| 569 | * are enumerated in xfs_trans.h. |
Alex Elder | b2ce397 | 2011-07-11 09:51:44 -0500 | [diff] [blame] | 570 | * |
| 571 | * Dynamically allocate the transaction structure from the transaction |
| 572 | * zone, initialize it, and return it to the caller. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 573 | */ |
Alex Elder | b2ce397 | 2011-07-11 09:51:44 -0500 | [diff] [blame] | 574 | xfs_trans_t * |
| 575 | xfs_trans_alloc( |
| 576 | xfs_mount_t *mp, |
| 577 | uint type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 578 | { |
Jan Kara | d9457dc | 2012-06-12 16:20:39 +0200 | [diff] [blame] | 579 | xfs_trans_t *tp; |
| 580 | |
| 581 | sb_start_intwrite(mp->m_super); |
| 582 | tp = _xfs_trans_alloc(mp, type, KM_SLEEP); |
| 583 | tp->t_flags |= XFS_TRANS_FREEZE_PROT; |
| 584 | return tp; |
Alex Elder | b2ce397 | 2011-07-11 09:51:44 -0500 | [diff] [blame] | 585 | } |
| 586 | |
| 587 | xfs_trans_t * |
| 588 | _xfs_trans_alloc( |
| 589 | xfs_mount_t *mp, |
| 590 | uint type, |
Al Viro | 77ba787 | 2012-04-02 06:24:04 -0400 | [diff] [blame] | 591 | xfs_km_flags_t memflags) |
Alex Elder | b2ce397 | 2011-07-11 09:51:44 -0500 | [diff] [blame] | 592 | { |
| 593 | xfs_trans_t *tp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 594 | |
Jan Kara | d9457dc | 2012-06-12 16:20:39 +0200 | [diff] [blame] | 595 | WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE); |
Nathan Scott | 34327e1 | 2006-06-09 17:11:55 +1000 | [diff] [blame] | 596 | atomic_inc(&mp->m_active_trans); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 597 | |
Christoph Hellwig | 80641dc | 2009-10-19 04:00:03 +0000 | [diff] [blame] | 598 | tp = kmem_zone_zalloc(xfs_trans_zone, memflags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | tp->t_magic = XFS_TRANS_MAGIC; |
| 600 | tp->t_type = type; |
| 601 | tp->t_mountp = mp; |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 602 | INIT_LIST_HEAD(&tp->t_items); |
Dave Chinner | ed3b4d6 | 2010-05-21 12:07:08 +1000 | [diff] [blame] | 603 | INIT_LIST_HEAD(&tp->t_busy); |
Nathan Scott | 34327e1 | 2006-06-09 17:11:55 +1000 | [diff] [blame] | 604 | return tp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 605 | } |
| 606 | |
| 607 | /* |
Dave Chinner | b1c1b5b | 2010-03-23 10:11:05 +1100 | [diff] [blame] | 608 | * Free the transaction structure. If there is more clean up |
| 609 | * to do when the structure is freed, add it here. |
| 610 | */ |
| 611 | STATIC void |
| 612 | xfs_trans_free( |
Dave Chinner | ed3b4d6 | 2010-05-21 12:07:08 +1000 | [diff] [blame] | 613 | struct xfs_trans *tp) |
Dave Chinner | b1c1b5b | 2010-03-23 10:11:05 +1100 | [diff] [blame] | 614 | { |
Dave Chinner | 4ecbfe6 | 2012-04-29 10:41:10 +0000 | [diff] [blame] | 615 | xfs_extent_busy_sort(&tp->t_busy); |
| 616 | xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false); |
Dave Chinner | ed3b4d6 | 2010-05-21 12:07:08 +1000 | [diff] [blame] | 617 | |
Dave Chinner | b1c1b5b | 2010-03-23 10:11:05 +1100 | [diff] [blame] | 618 | atomic_dec(&tp->t_mountp->m_active_trans); |
Jan Kara | d9457dc | 2012-06-12 16:20:39 +0200 | [diff] [blame] | 619 | if (tp->t_flags & XFS_TRANS_FREEZE_PROT) |
| 620 | sb_end_intwrite(tp->t_mountp->m_super); |
Dave Chinner | b1c1b5b | 2010-03-23 10:11:05 +1100 | [diff] [blame] | 621 | xfs_trans_free_dqinfo(tp); |
| 622 | kmem_zone_free(xfs_trans_zone, tp); |
| 623 | } |
| 624 | |
| 625 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 626 | * This is called to create a new transaction which will share the |
| 627 | * permanent log reservation of the given transaction. The remaining |
| 628 | * unused block and rt extent reservations are also inherited. This |
| 629 | * implies that the original transaction is no longer allowed to allocate |
| 630 | * blocks. Locks and log items, however, are no inherited. They must |
| 631 | * be added to the new transaction explicitly. |
| 632 | */ |
| 633 | xfs_trans_t * |
| 634 | xfs_trans_dup( |
| 635 | xfs_trans_t *tp) |
| 636 | { |
| 637 | xfs_trans_t *ntp; |
| 638 | |
| 639 | ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP); |
| 640 | |
| 641 | /* |
| 642 | * Initialize the new transaction structure. |
| 643 | */ |
| 644 | ntp->t_magic = XFS_TRANS_MAGIC; |
| 645 | ntp->t_type = tp->t_type; |
| 646 | ntp->t_mountp = tp->t_mountp; |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 647 | INIT_LIST_HEAD(&ntp->t_items); |
Dave Chinner | ed3b4d6 | 2010-05-21 12:07:08 +1000 | [diff] [blame] | 648 | INIT_LIST_HEAD(&ntp->t_busy); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 649 | |
| 650 | ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 651 | ASSERT(tp->t_ticket != NULL); |
Nathan Scott | cfcbbbd | 2005-11-02 15:12:04 +1100 | [diff] [blame] | 652 | |
Jan Kara | d9457dc | 2012-06-12 16:20:39 +0200 | [diff] [blame] | 653 | ntp->t_flags = XFS_TRANS_PERM_LOG_RES | |
| 654 | (tp->t_flags & XFS_TRANS_RESERVE) | |
| 655 | (tp->t_flags & XFS_TRANS_FREEZE_PROT); |
| 656 | /* We gave our writer reference to the new transaction */ |
| 657 | tp->t_flags &= ~XFS_TRANS_FREEZE_PROT; |
Dave Chinner | cc09c0d | 2008-11-17 17:37:10 +1100 | [diff] [blame] | 658 | ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 659 | ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used; |
| 660 | tp->t_blk_res = tp->t_blk_res_used; |
| 661 | ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used; |
| 662 | tp->t_rtx_res = tp->t_rtx_res_used; |
Nathan Scott | 59c1b08 | 2006-06-09 14:59:13 +1000 | [diff] [blame] | 663 | ntp->t_pflags = tp->t_pflags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 664 | |
Christoph Hellwig | 7d09525 | 2009-06-08 15:33:32 +0200 | [diff] [blame] | 665 | xfs_trans_dup_dqinfo(tp, ntp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 666 | |
| 667 | atomic_inc(&tp->t_mountp->m_active_trans); |
| 668 | return ntp; |
| 669 | } |
| 670 | |
| 671 | /* |
| 672 | * This is called to reserve free disk blocks and log space for the |
| 673 | * given transaction. This must be done before allocating any resources |
| 674 | * within the transaction. |
| 675 | * |
| 676 | * This will return ENOSPC if there are not enough blocks available. |
| 677 | * It will sleep waiting for available log space. |
| 678 | * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which |
| 679 | * is used by long running transactions. If any one of the reservations |
| 680 | * fails then they will all be backed out. |
| 681 | * |
| 682 | * This does not do quota reservations. That typically is done by the |
| 683 | * caller afterwards. |
| 684 | */ |
| 685 | int |
| 686 | xfs_trans_reserve( |
| 687 | xfs_trans_t *tp, |
| 688 | uint blocks, |
| 689 | uint logspace, |
| 690 | uint rtextents, |
| 691 | uint flags, |
| 692 | uint logcount) |
| 693 | { |
Nathan Scott | 59c1b08 | 2006-06-09 14:59:13 +1000 | [diff] [blame] | 694 | int error = 0; |
| 695 | int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 696 | |
| 697 | /* Mark this thread as being in a transaction */ |
Nathan Scott | 59c1b08 | 2006-06-09 14:59:13 +1000 | [diff] [blame] | 698 | current_set_flags_nested(&tp->t_pflags, PF_FSTRANS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 699 | |
| 700 | /* |
| 701 | * Attempt to reserve the needed disk blocks by decrementing |
| 702 | * the number needed from the number available. This will |
| 703 | * fail if the count would go below zero. |
| 704 | */ |
| 705 | if (blocks > 0) { |
Christoph Hellwig | 96540c7 | 2010-09-30 02:25:55 +0000 | [diff] [blame] | 706 | error = xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS, |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 707 | -((int64_t)blocks), rsvd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 708 | if (error != 0) { |
Nathan Scott | 59c1b08 | 2006-06-09 14:59:13 +1000 | [diff] [blame] | 709 | current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 710 | return (XFS_ERROR(ENOSPC)); |
| 711 | } |
| 712 | tp->t_blk_res += blocks; |
| 713 | } |
| 714 | |
| 715 | /* |
| 716 | * Reserve the log space needed for this transaction. |
| 717 | */ |
| 718 | if (logspace > 0) { |
Christoph Hellwig | 9006fb9 | 2012-02-20 02:31:31 +0000 | [diff] [blame] | 719 | bool permanent = false; |
| 720 | |
| 721 | ASSERT(tp->t_log_res == 0 || tp->t_log_res == logspace); |
| 722 | ASSERT(tp->t_log_count == 0 || tp->t_log_count == logcount); |
| 723 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 724 | if (flags & XFS_TRANS_PERM_LOG_RES) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 725 | tp->t_flags |= XFS_TRANS_PERM_LOG_RES; |
Christoph Hellwig | 9006fb9 | 2012-02-20 02:31:31 +0000 | [diff] [blame] | 726 | permanent = true; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 727 | } else { |
| 728 | ASSERT(tp->t_ticket == NULL); |
| 729 | ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 730 | } |
| 731 | |
Christoph Hellwig | 9006fb9 | 2012-02-20 02:31:31 +0000 | [diff] [blame] | 732 | if (tp->t_ticket != NULL) { |
| 733 | ASSERT(flags & XFS_TRANS_PERM_LOG_RES); |
| 734 | error = xfs_log_regrant(tp->t_mountp, tp->t_ticket); |
| 735 | } else { |
| 736 | error = xfs_log_reserve(tp->t_mountp, logspace, |
| 737 | logcount, &tp->t_ticket, |
| 738 | XFS_TRANSACTION, permanent, |
| 739 | tp->t_type); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 740 | } |
Christoph Hellwig | 9006fb9 | 2012-02-20 02:31:31 +0000 | [diff] [blame] | 741 | |
| 742 | if (error) |
| 743 | goto undo_blocks; |
| 744 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 745 | tp->t_log_res = logspace; |
| 746 | tp->t_log_count = logcount; |
| 747 | } |
| 748 | |
| 749 | /* |
| 750 | * Attempt to reserve the needed realtime extents by decrementing |
| 751 | * the number needed from the number available. This will |
| 752 | * fail if the count would go below zero. |
| 753 | */ |
| 754 | if (rtextents > 0) { |
| 755 | error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS, |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 756 | -((int64_t)rtextents), rsvd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 757 | if (error) { |
| 758 | error = XFS_ERROR(ENOSPC); |
| 759 | goto undo_log; |
| 760 | } |
| 761 | tp->t_rtx_res += rtextents; |
| 762 | } |
| 763 | |
| 764 | return 0; |
| 765 | |
| 766 | /* |
| 767 | * Error cases jump to one of these labels to undo any |
| 768 | * reservations which have already been performed. |
| 769 | */ |
| 770 | undo_log: |
| 771 | if (logspace > 0) { |
Christoph Hellwig | 9006fb9 | 2012-02-20 02:31:31 +0000 | [diff] [blame] | 772 | int log_flags; |
| 773 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 774 | if (flags & XFS_TRANS_PERM_LOG_RES) { |
| 775 | log_flags = XFS_LOG_REL_PERM_RESERV; |
| 776 | } else { |
| 777 | log_flags = 0; |
| 778 | } |
| 779 | xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags); |
| 780 | tp->t_ticket = NULL; |
| 781 | tp->t_log_res = 0; |
| 782 | tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES; |
| 783 | } |
| 784 | |
| 785 | undo_blocks: |
| 786 | if (blocks > 0) { |
Christoph Hellwig | 96540c7 | 2010-09-30 02:25:55 +0000 | [diff] [blame] | 787 | xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS, |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 788 | (int64_t)blocks, rsvd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 789 | tp->t_blk_res = 0; |
| 790 | } |
| 791 | |
Nathan Scott | 59c1b08 | 2006-06-09 14:59:13 +1000 | [diff] [blame] | 792 | current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 793 | |
Nathan Scott | 59c1b08 | 2006-06-09 14:59:13 +1000 | [diff] [blame] | 794 | return error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 795 | } |
| 796 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 797 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 798 | * Record the indicated change to the given field for application |
| 799 | * to the file system's superblock when the transaction commits. |
| 800 | * For now, just store the change in the transaction structure. |
| 801 | * |
| 802 | * Mark the transaction structure to indicate that the superblock |
| 803 | * needs to be updated before committing. |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 804 | * |
| 805 | * Because we may not be keeping track of allocated/free inodes and |
| 806 | * used filesystem blocks in the superblock, we do not mark the |
| 807 | * superblock dirty in this transaction if we modify these fields. |
| 808 | * We still need to update the transaction deltas so that they get |
| 809 | * applied to the incore superblock, but we don't want them to |
| 810 | * cause the superblock to get locked and logged if these are the |
| 811 | * only fields in the superblock that the transaction modifies. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 812 | */ |
| 813 | void |
| 814 | xfs_trans_mod_sb( |
| 815 | xfs_trans_t *tp, |
| 816 | uint field, |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 817 | int64_t delta) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 818 | { |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 819 | uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY); |
| 820 | xfs_mount_t *mp = tp->t_mountp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 821 | |
| 822 | switch (field) { |
| 823 | case XFS_TRANS_SB_ICOUNT: |
| 824 | tp->t_icount_delta += delta; |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 825 | if (xfs_sb_version_haslazysbcount(&mp->m_sb)) |
| 826 | flags &= ~XFS_TRANS_SB_DIRTY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 827 | break; |
| 828 | case XFS_TRANS_SB_IFREE: |
| 829 | tp->t_ifree_delta += delta; |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 830 | if (xfs_sb_version_haslazysbcount(&mp->m_sb)) |
| 831 | flags &= ~XFS_TRANS_SB_DIRTY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 832 | break; |
| 833 | case XFS_TRANS_SB_FDBLOCKS: |
| 834 | /* |
| 835 | * Track the number of blocks allocated in the |
| 836 | * transaction. Make sure it does not exceed the |
| 837 | * number reserved. |
| 838 | */ |
| 839 | if (delta < 0) { |
| 840 | tp->t_blk_res_used += (uint)-delta; |
| 841 | ASSERT(tp->t_blk_res_used <= tp->t_blk_res); |
| 842 | } |
| 843 | tp->t_fdblocks_delta += delta; |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 844 | if (xfs_sb_version_haslazysbcount(&mp->m_sb)) |
| 845 | flags &= ~XFS_TRANS_SB_DIRTY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 846 | break; |
| 847 | case XFS_TRANS_SB_RES_FDBLOCKS: |
| 848 | /* |
| 849 | * The allocation has already been applied to the |
| 850 | * in-core superblock's counter. This should only |
| 851 | * be applied to the on-disk superblock. |
| 852 | */ |
| 853 | ASSERT(delta < 0); |
| 854 | tp->t_res_fdblocks_delta += delta; |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 855 | if (xfs_sb_version_haslazysbcount(&mp->m_sb)) |
| 856 | flags &= ~XFS_TRANS_SB_DIRTY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 857 | break; |
| 858 | case XFS_TRANS_SB_FREXTENTS: |
| 859 | /* |
| 860 | * Track the number of blocks allocated in the |
| 861 | * transaction. Make sure it does not exceed the |
| 862 | * number reserved. |
| 863 | */ |
| 864 | if (delta < 0) { |
| 865 | tp->t_rtx_res_used += (uint)-delta; |
| 866 | ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res); |
| 867 | } |
| 868 | tp->t_frextents_delta += delta; |
| 869 | break; |
| 870 | case XFS_TRANS_SB_RES_FREXTENTS: |
| 871 | /* |
| 872 | * The allocation has already been applied to the |
Nathan Scott | c41564b | 2006-03-29 08:55:14 +1000 | [diff] [blame] | 873 | * in-core superblock's counter. This should only |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 874 | * be applied to the on-disk superblock. |
| 875 | */ |
| 876 | ASSERT(delta < 0); |
| 877 | tp->t_res_frextents_delta += delta; |
| 878 | break; |
| 879 | case XFS_TRANS_SB_DBLOCKS: |
| 880 | ASSERT(delta > 0); |
| 881 | tp->t_dblocks_delta += delta; |
| 882 | break; |
| 883 | case XFS_TRANS_SB_AGCOUNT: |
| 884 | ASSERT(delta > 0); |
| 885 | tp->t_agcount_delta += delta; |
| 886 | break; |
| 887 | case XFS_TRANS_SB_IMAXPCT: |
| 888 | tp->t_imaxpct_delta += delta; |
| 889 | break; |
| 890 | case XFS_TRANS_SB_REXTSIZE: |
| 891 | tp->t_rextsize_delta += delta; |
| 892 | break; |
| 893 | case XFS_TRANS_SB_RBMBLOCKS: |
| 894 | tp->t_rbmblocks_delta += delta; |
| 895 | break; |
| 896 | case XFS_TRANS_SB_RBLOCKS: |
| 897 | tp->t_rblocks_delta += delta; |
| 898 | break; |
| 899 | case XFS_TRANS_SB_REXTENTS: |
| 900 | tp->t_rextents_delta += delta; |
| 901 | break; |
| 902 | case XFS_TRANS_SB_REXTSLOG: |
| 903 | tp->t_rextslog_delta += delta; |
| 904 | break; |
| 905 | default: |
| 906 | ASSERT(0); |
| 907 | return; |
| 908 | } |
| 909 | |
David Chinner | 210c6f1 | 2007-05-24 15:26:51 +1000 | [diff] [blame] | 910 | tp->t_flags |= flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 911 | } |
| 912 | |
| 913 | /* |
| 914 | * xfs_trans_apply_sb_deltas() is called from the commit code |
| 915 | * to bring the superblock buffer into the current transaction |
| 916 | * and modify it as requested by earlier calls to xfs_trans_mod_sb(). |
| 917 | * |
| 918 | * For now we just look at each field allowed to change and change |
| 919 | * it if necessary. |
| 920 | */ |
| 921 | STATIC void |
| 922 | xfs_trans_apply_sb_deltas( |
| 923 | xfs_trans_t *tp) |
| 924 | { |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 925 | xfs_dsb_t *sbp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 926 | xfs_buf_t *bp; |
| 927 | int whole = 0; |
| 928 | |
| 929 | bp = xfs_trans_getsb(tp, tp->t_mountp, 0); |
| 930 | sbp = XFS_BUF_TO_SBP(bp); |
| 931 | |
| 932 | /* |
| 933 | * Check that superblock mods match the mods made to AGF counters. |
| 934 | */ |
| 935 | ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) == |
| 936 | (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta + |
| 937 | tp->t_ag_btree_delta)); |
| 938 | |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 939 | /* |
| 940 | * Only update the superblock counters if we are logging them |
| 941 | */ |
| 942 | if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) { |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 943 | if (tp->t_icount_delta) |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 944 | be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta); |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 945 | if (tp->t_ifree_delta) |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 946 | be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta); |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 947 | if (tp->t_fdblocks_delta) |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 948 | be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta); |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 949 | if (tp->t_res_fdblocks_delta) |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 950 | be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 951 | } |
| 952 | |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 953 | if (tp->t_frextents_delta) |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 954 | be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta); |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 955 | if (tp->t_res_frextents_delta) |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 956 | be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta); |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 957 | |
| 958 | if (tp->t_dblocks_delta) { |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 959 | be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 960 | whole = 1; |
| 961 | } |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 962 | if (tp->t_agcount_delta) { |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 963 | be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 964 | whole = 1; |
| 965 | } |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 966 | if (tp->t_imaxpct_delta) { |
| 967 | sbp->sb_imax_pct += tp->t_imaxpct_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 968 | whole = 1; |
| 969 | } |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 970 | if (tp->t_rextsize_delta) { |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 971 | be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 972 | whole = 1; |
| 973 | } |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 974 | if (tp->t_rbmblocks_delta) { |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 975 | be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 976 | whole = 1; |
| 977 | } |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 978 | if (tp->t_rblocks_delta) { |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 979 | be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 980 | whole = 1; |
| 981 | } |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 982 | if (tp->t_rextents_delta) { |
Marcin Slusarz | 413d57c | 2008-02-13 15:03:29 -0800 | [diff] [blame] | 983 | be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 984 | whole = 1; |
| 985 | } |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 986 | if (tp->t_rextslog_delta) { |
| 987 | sbp->sb_rextslog += tp->t_rextslog_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 988 | whole = 1; |
| 989 | } |
| 990 | |
| 991 | if (whole) |
| 992 | /* |
Nathan Scott | c41564b | 2006-03-29 08:55:14 +1000 | [diff] [blame] | 993 | * Log the whole thing, the fields are noncontiguous. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 994 | */ |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 995 | xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 996 | else |
| 997 | /* |
| 998 | * Since all the modifiable fields are contiguous, we |
| 999 | * can get away with this. |
| 1000 | */ |
Christoph Hellwig | 2bdf7cd | 2007-08-28 13:58:06 +1000 | [diff] [blame] | 1001 | xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount), |
| 1002 | offsetof(xfs_dsb_t, sb_frextents) + |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1003 | sizeof(sbp->sb_frextents) - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1004 | } |
| 1005 | |
| 1006 | /* |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1007 | * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations |
| 1008 | * and apply superblock counter changes to the in-core superblock. The |
| 1009 | * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT |
| 1010 | * applied to the in-core superblock. The idea is that that has already been |
| 1011 | * done. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1012 | * |
| 1013 | * This is done efficiently with a single call to xfs_mod_incore_sb_batch(). |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1014 | * However, we have to ensure that we only modify each superblock field only |
| 1015 | * once because the application of the delta values may not be atomic. That can |
| 1016 | * lead to ENOSPC races occurring if we have two separate modifcations of the |
| 1017 | * free space counter to put back the entire reservation and then take away |
| 1018 | * what we used. |
| 1019 | * |
| 1020 | * If we are not logging superblock counters, then the inode allocated/free and |
| 1021 | * used block counts are not updated in the on disk superblock. In this case, |
| 1022 | * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we |
| 1023 | * still need to update the incore superblock with the changes. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1024 | */ |
Dave Chinner | 71e330b | 2010-05-21 14:37:18 +1000 | [diff] [blame] | 1025 | void |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1026 | xfs_trans_unreserve_and_mod_sb( |
| 1027 | xfs_trans_t *tp) |
| 1028 | { |
Christoph Hellwig | 1b04071 | 2010-09-30 02:25:56 +0000 | [diff] [blame] | 1029 | xfs_mod_sb_t msb[9]; /* If you add cases, add entries */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1030 | xfs_mod_sb_t *msbp; |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 1031 | xfs_mount_t *mp = tp->t_mountp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1032 | /* REFERENCED */ |
| 1033 | int error; |
| 1034 | int rsvd; |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1035 | int64_t blkdelta = 0; |
| 1036 | int64_t rtxdelta = 0; |
Christoph Hellwig | 1b04071 | 2010-09-30 02:25:56 +0000 | [diff] [blame] | 1037 | int64_t idelta = 0; |
| 1038 | int64_t ifreedelta = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1039 | |
| 1040 | msbp = msb; |
| 1041 | rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; |
| 1042 | |
Christoph Hellwig | 1b04071 | 2010-09-30 02:25:56 +0000 | [diff] [blame] | 1043 | /* calculate deltas */ |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1044 | if (tp->t_blk_res > 0) |
| 1045 | blkdelta = tp->t_blk_res; |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1046 | if ((tp->t_fdblocks_delta != 0) && |
| 1047 | (xfs_sb_version_haslazysbcount(&mp->m_sb) || |
| 1048 | (tp->t_flags & XFS_TRANS_SB_DIRTY))) |
| 1049 | blkdelta += tp->t_fdblocks_delta; |
| 1050 | |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1051 | if (tp->t_rtx_res > 0) |
| 1052 | rtxdelta = tp->t_rtx_res; |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1053 | if ((tp->t_frextents_delta != 0) && |
| 1054 | (tp->t_flags & XFS_TRANS_SB_DIRTY)) |
| 1055 | rtxdelta += tp->t_frextents_delta; |
| 1056 | |
Christoph Hellwig | 1b04071 | 2010-09-30 02:25:56 +0000 | [diff] [blame] | 1057 | if (xfs_sb_version_haslazysbcount(&mp->m_sb) || |
| 1058 | (tp->t_flags & XFS_TRANS_SB_DIRTY)) { |
| 1059 | idelta = tp->t_icount_delta; |
| 1060 | ifreedelta = tp->t_ifree_delta; |
| 1061 | } |
| 1062 | |
| 1063 | /* apply the per-cpu counters */ |
| 1064 | if (blkdelta) { |
| 1065 | error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, |
| 1066 | blkdelta, rsvd); |
| 1067 | if (error) |
| 1068 | goto out; |
| 1069 | } |
| 1070 | |
| 1071 | if (idelta) { |
| 1072 | error = xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT, |
| 1073 | idelta, rsvd); |
| 1074 | if (error) |
| 1075 | goto out_undo_fdblocks; |
| 1076 | } |
| 1077 | |
| 1078 | if (ifreedelta) { |
| 1079 | error = xfs_icsb_modify_counters(mp, XFS_SBS_IFREE, |
| 1080 | ifreedelta, rsvd); |
| 1081 | if (error) |
| 1082 | goto out_undo_icount; |
| 1083 | } |
| 1084 | |
| 1085 | /* apply remaining deltas */ |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1086 | if (rtxdelta != 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1087 | msbp->msb_field = XFS_SBS_FREXTENTS; |
David Chinner | 45c3414 | 2007-06-18 16:49:44 +1000 | [diff] [blame] | 1088 | msbp->msb_delta = rtxdelta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1089 | msbp++; |
| 1090 | } |
| 1091 | |
David Chinner | 92821e2 | 2007-05-24 15:26:31 +1000 | [diff] [blame] | 1092 | if (tp->t_flags & XFS_TRANS_SB_DIRTY) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1093 | if (tp->t_dblocks_delta != 0) { |
| 1094 | msbp->msb_field = XFS_SBS_DBLOCKS; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1095 | msbp->msb_delta = tp->t_dblocks_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1096 | msbp++; |
| 1097 | } |
| 1098 | if (tp->t_agcount_delta != 0) { |
| 1099 | msbp->msb_field = XFS_SBS_AGCOUNT; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1100 | msbp->msb_delta = tp->t_agcount_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1101 | msbp++; |
| 1102 | } |
| 1103 | if (tp->t_imaxpct_delta != 0) { |
| 1104 | msbp->msb_field = XFS_SBS_IMAX_PCT; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1105 | msbp->msb_delta = tp->t_imaxpct_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1106 | msbp++; |
| 1107 | } |
| 1108 | if (tp->t_rextsize_delta != 0) { |
| 1109 | msbp->msb_field = XFS_SBS_REXTSIZE; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1110 | msbp->msb_delta = tp->t_rextsize_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1111 | msbp++; |
| 1112 | } |
| 1113 | if (tp->t_rbmblocks_delta != 0) { |
| 1114 | msbp->msb_field = XFS_SBS_RBMBLOCKS; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1115 | msbp->msb_delta = tp->t_rbmblocks_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1116 | msbp++; |
| 1117 | } |
| 1118 | if (tp->t_rblocks_delta != 0) { |
| 1119 | msbp->msb_field = XFS_SBS_RBLOCKS; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1120 | msbp->msb_delta = tp->t_rblocks_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1121 | msbp++; |
| 1122 | } |
| 1123 | if (tp->t_rextents_delta != 0) { |
| 1124 | msbp->msb_field = XFS_SBS_REXTENTS; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1125 | msbp->msb_delta = tp->t_rextents_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1126 | msbp++; |
| 1127 | } |
| 1128 | if (tp->t_rextslog_delta != 0) { |
| 1129 | msbp->msb_field = XFS_SBS_REXTSLOG; |
David Chinner | 20f4ebf | 2007-02-10 18:36:10 +1100 | [diff] [blame] | 1130 | msbp->msb_delta = tp->t_rextslog_delta; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1131 | msbp++; |
| 1132 | } |
| 1133 | } |
| 1134 | |
| 1135 | /* |
| 1136 | * If we need to change anything, do it. |
| 1137 | */ |
| 1138 | if (msbp > msb) { |
| 1139 | error = xfs_mod_incore_sb_batch(tp->t_mountp, msb, |
| 1140 | (uint)(msbp - msb), rsvd); |
Christoph Hellwig | 1b04071 | 2010-09-30 02:25:56 +0000 | [diff] [blame] | 1141 | if (error) |
| 1142 | goto out_undo_ifreecount; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1143 | } |
Christoph Hellwig | 1b04071 | 2010-09-30 02:25:56 +0000 | [diff] [blame] | 1144 | |
| 1145 | return; |
| 1146 | |
| 1147 | out_undo_ifreecount: |
| 1148 | if (ifreedelta) |
| 1149 | xfs_icsb_modify_counters(mp, XFS_SBS_IFREE, -ifreedelta, rsvd); |
| 1150 | out_undo_icount: |
| 1151 | if (idelta) |
| 1152 | xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT, -idelta, rsvd); |
| 1153 | out_undo_fdblocks: |
| 1154 | if (blkdelta) |
| 1155 | xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, -blkdelta, rsvd); |
| 1156 | out: |
Jesper Juhl | 1884bd8 | 2010-12-25 20:14:53 +0000 | [diff] [blame] | 1157 | ASSERT(error == 0); |
Christoph Hellwig | 1b04071 | 2010-09-30 02:25:56 +0000 | [diff] [blame] | 1158 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1159 | } |
| 1160 | |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1161 | /* |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 1162 | * Add the given log item to the transaction's list of log items. |
| 1163 | * |
| 1164 | * The log item will now point to its new descriptor with its li_desc field. |
| 1165 | */ |
| 1166 | void |
| 1167 | xfs_trans_add_item( |
| 1168 | struct xfs_trans *tp, |
| 1169 | struct xfs_log_item *lip) |
| 1170 | { |
| 1171 | struct xfs_log_item_desc *lidp; |
| 1172 | |
Jesper Juhl | f65020a | 2012-02-13 20:51:05 +0000 | [diff] [blame] | 1173 | ASSERT(lip->li_mountp == tp->t_mountp); |
| 1174 | ASSERT(lip->li_ailp == tp->t_mountp->m_ail); |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 1175 | |
Dave Chinner | 4386970 | 2010-07-20 17:53:44 +1000 | [diff] [blame] | 1176 | lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS); |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 1177 | |
| 1178 | lidp->lid_item = lip; |
| 1179 | lidp->lid_flags = 0; |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 1180 | list_add_tail(&lidp->lid_trans, &tp->t_items); |
| 1181 | |
| 1182 | lip->li_desc = lidp; |
| 1183 | } |
| 1184 | |
| 1185 | STATIC void |
| 1186 | xfs_trans_free_item_desc( |
| 1187 | struct xfs_log_item_desc *lidp) |
| 1188 | { |
| 1189 | list_del_init(&lidp->lid_trans); |
| 1190 | kmem_zone_free(xfs_log_item_desc_zone, lidp); |
| 1191 | } |
| 1192 | |
| 1193 | /* |
| 1194 | * Unlink and free the given descriptor. |
| 1195 | */ |
| 1196 | void |
| 1197 | xfs_trans_del_item( |
| 1198 | struct xfs_log_item *lip) |
| 1199 | { |
| 1200 | xfs_trans_free_item_desc(lip->li_desc); |
| 1201 | lip->li_desc = NULL; |
| 1202 | } |
| 1203 | |
| 1204 | /* |
| 1205 | * Unlock all of the items of a transaction and free all the descriptors |
| 1206 | * of that transaction. |
| 1207 | */ |
Dave Chinner | d17c701 | 2010-08-24 11:42:52 +1000 | [diff] [blame] | 1208 | void |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 1209 | xfs_trans_free_items( |
| 1210 | struct xfs_trans *tp, |
| 1211 | xfs_lsn_t commit_lsn, |
| 1212 | int flags) |
| 1213 | { |
| 1214 | struct xfs_log_item_desc *lidp, *next; |
| 1215 | |
| 1216 | list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) { |
| 1217 | struct xfs_log_item *lip = lidp->lid_item; |
| 1218 | |
| 1219 | lip->li_desc = NULL; |
| 1220 | |
| 1221 | if (commit_lsn != NULLCOMMITLSN) |
| 1222 | IOP_COMMITTING(lip, commit_lsn); |
| 1223 | if (flags & XFS_TRANS_ABORT) |
| 1224 | lip->li_flags |= XFS_LI_ABORTED; |
| 1225 | IOP_UNLOCK(lip); |
| 1226 | |
| 1227 | xfs_trans_free_item_desc(lidp); |
| 1228 | } |
| 1229 | } |
| 1230 | |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1231 | static inline void |
| 1232 | xfs_log_item_batch_insert( |
| 1233 | struct xfs_ail *ailp, |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1234 | struct xfs_ail_cursor *cur, |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1235 | struct xfs_log_item **log_items, |
| 1236 | int nr_items, |
| 1237 | xfs_lsn_t commit_lsn) |
| 1238 | { |
| 1239 | int i; |
| 1240 | |
| 1241 | spin_lock(&ailp->xa_lock); |
| 1242 | /* xfs_trans_ail_update_bulk drops ailp->xa_lock */ |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1243 | xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn); |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1244 | |
| 1245 | for (i = 0; i < nr_items; i++) |
| 1246 | IOP_UNPIN(log_items[i], 0); |
| 1247 | } |
| 1248 | |
| 1249 | /* |
| 1250 | * Bulk operation version of xfs_trans_committed that takes a log vector of |
| 1251 | * items to insert into the AIL. This uses bulk AIL insertion techniques to |
| 1252 | * minimise lock traffic. |
Dave Chinner | e34a314 | 2011-01-27 12:13:35 +1100 | [diff] [blame] | 1253 | * |
| 1254 | * If we are called with the aborted flag set, it is because a log write during |
| 1255 | * a CIL checkpoint commit has failed. In this case, all the items in the |
| 1256 | * checkpoint have already gone through IOP_COMMITED and IOP_UNLOCK, which |
| 1257 | * means that checkpoint commit abort handling is treated exactly the same |
| 1258 | * as an iclog write error even though we haven't started any IO yet. Hence in |
| 1259 | * this case all we need to do is IOP_COMMITTED processing, followed by an |
| 1260 | * IOP_UNPIN(aborted) call. |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1261 | * |
| 1262 | * The AIL cursor is used to optimise the insert process. If commit_lsn is not |
| 1263 | * at the end of the AIL, the insert cursor avoids the need to walk |
| 1264 | * the AIL to find the insertion point on every xfs_log_item_batch_insert() |
| 1265 | * call. This saves a lot of needless list walking and is a net win, even |
| 1266 | * though it slightly increases that amount of AIL lock traffic to set it up |
| 1267 | * and tear it down. |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1268 | */ |
| 1269 | void |
| 1270 | xfs_trans_committed_bulk( |
| 1271 | struct xfs_ail *ailp, |
| 1272 | struct xfs_log_vec *log_vector, |
| 1273 | xfs_lsn_t commit_lsn, |
| 1274 | int aborted) |
| 1275 | { |
| 1276 | #define LOG_ITEM_BATCH_SIZE 32 |
| 1277 | struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE]; |
| 1278 | struct xfs_log_vec *lv; |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1279 | struct xfs_ail_cursor cur; |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1280 | int i = 0; |
| 1281 | |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1282 | spin_lock(&ailp->xa_lock); |
| 1283 | xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn); |
| 1284 | spin_unlock(&ailp->xa_lock); |
| 1285 | |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1286 | /* unpin all the log items */ |
| 1287 | for (lv = log_vector; lv; lv = lv->lv_next ) { |
| 1288 | struct xfs_log_item *lip = lv->lv_item; |
| 1289 | xfs_lsn_t item_lsn; |
| 1290 | |
| 1291 | if (aborted) |
| 1292 | lip->li_flags |= XFS_LI_ABORTED; |
| 1293 | item_lsn = IOP_COMMITTED(lip, commit_lsn); |
| 1294 | |
Dave Chinner | 1316d4d | 2011-07-04 05:27:36 +0000 | [diff] [blame] | 1295 | /* item_lsn of -1 means the item needs no further processing */ |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1296 | if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0) |
| 1297 | continue; |
| 1298 | |
Dave Chinner | e34a314 | 2011-01-27 12:13:35 +1100 | [diff] [blame] | 1299 | /* |
| 1300 | * if we are aborting the operation, no point in inserting the |
| 1301 | * object into the AIL as we are in a shutdown situation. |
| 1302 | */ |
| 1303 | if (aborted) { |
| 1304 | ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount)); |
| 1305 | IOP_UNPIN(lip, 1); |
| 1306 | continue; |
| 1307 | } |
| 1308 | |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1309 | if (item_lsn != commit_lsn) { |
| 1310 | |
| 1311 | /* |
| 1312 | * Not a bulk update option due to unusual item_lsn. |
| 1313 | * Push into AIL immediately, rechecking the lsn once |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1314 | * we have the ail lock. Then unpin the item. This does |
| 1315 | * not affect the AIL cursor the bulk insert path is |
| 1316 | * using. |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1317 | */ |
| 1318 | spin_lock(&ailp->xa_lock); |
| 1319 | if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) |
| 1320 | xfs_trans_ail_update(ailp, lip, item_lsn); |
| 1321 | else |
| 1322 | spin_unlock(&ailp->xa_lock); |
| 1323 | IOP_UNPIN(lip, 0); |
| 1324 | continue; |
| 1325 | } |
| 1326 | |
| 1327 | /* Item is a candidate for bulk AIL insert. */ |
| 1328 | log_items[i++] = lv->lv_item; |
| 1329 | if (i >= LOG_ITEM_BATCH_SIZE) { |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1330 | xfs_log_item_batch_insert(ailp, &cur, log_items, |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1331 | LOG_ITEM_BATCH_SIZE, commit_lsn); |
| 1332 | i = 0; |
| 1333 | } |
| 1334 | } |
| 1335 | |
| 1336 | /* make sure we insert the remainder! */ |
| 1337 | if (i) |
Dave Chinner | 1d8c95a | 2011-07-18 03:40:16 +0000 | [diff] [blame] | 1338 | xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn); |
| 1339 | |
| 1340 | spin_lock(&ailp->xa_lock); |
| 1341 | xfs_trans_ail_cursor_done(ailp, &cur); |
| 1342 | spin_unlock(&ailp->xa_lock); |
Dave Chinner | 0e57f6a | 2010-12-20 12:02:19 +1100 | [diff] [blame] | 1343 | } |
| 1344 | |
Dave Chinner | b1c1b5b | 2010-03-23 10:11:05 +1100 | [diff] [blame] | 1345 | /* |
Christoph Hellwig | b103705 | 2011-09-19 14:55:51 +0000 | [diff] [blame] | 1346 | * Commit the given transaction to the log. |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1347 | * |
| 1348 | * XFS disk error handling mechanism is not based on a typical |
| 1349 | * transaction abort mechanism. Logically after the filesystem |
| 1350 | * gets marked 'SHUTDOWN', we can't let any new transactions |
| 1351 | * be durable - ie. committed to disk - because some metadata might |
| 1352 | * be inconsistent. In such cases, this returns an error, and the |
| 1353 | * caller may assume that all locked objects joined to the transaction |
| 1354 | * have already been unlocked as if the commit had succeeded. |
| 1355 | * Do not reference the transaction structure after this call. |
| 1356 | */ |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1357 | int |
Christoph Hellwig | b103705 | 2011-09-19 14:55:51 +0000 | [diff] [blame] | 1358 | xfs_trans_commit( |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1359 | struct xfs_trans *tp, |
Christoph Hellwig | b103705 | 2011-09-19 14:55:51 +0000 | [diff] [blame] | 1360 | uint flags) |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1361 | { |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1362 | struct xfs_mount *mp = tp->t_mountp; |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1363 | xfs_lsn_t commit_lsn = -1; |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1364 | int error = 0; |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1365 | int log_flags = 0; |
| 1366 | int sync = tp->t_flags & XFS_TRANS_SYNC; |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1367 | |
| 1368 | /* |
| 1369 | * Determine whether this commit is releasing a permanent |
| 1370 | * log reservation or not. |
| 1371 | */ |
| 1372 | if (flags & XFS_TRANS_RELEASE_LOG_RES) { |
| 1373 | ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); |
| 1374 | log_flags = XFS_LOG_REL_PERM_RESERV; |
| 1375 | } |
| 1376 | |
| 1377 | /* |
| 1378 | * If there is nothing to be logged by the transaction, |
| 1379 | * then unlock all of the items associated with the |
| 1380 | * transaction and free the transaction structure. |
| 1381 | * Also make sure to return any reserved blocks to |
| 1382 | * the free pool. |
| 1383 | */ |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1384 | if (!(tp->t_flags & XFS_TRANS_DIRTY)) |
| 1385 | goto out_unreserve; |
| 1386 | |
| 1387 | if (XFS_FORCED_SHUTDOWN(mp)) { |
| 1388 | error = XFS_ERROR(EIO); |
| 1389 | goto out_unreserve; |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1390 | } |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1391 | |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1392 | ASSERT(tp->t_ticket != NULL); |
| 1393 | |
| 1394 | /* |
| 1395 | * If we need to update the superblock, then do it now. |
| 1396 | */ |
| 1397 | if (tp->t_flags & XFS_TRANS_SB_DIRTY) |
| 1398 | xfs_trans_apply_sb_deltas(tp); |
| 1399 | xfs_trans_apply_dquot_deltas(tp); |
| 1400 | |
Christoph Hellwig | 0244b96 | 2011-12-06 21:58:08 +0000 | [diff] [blame] | 1401 | error = xfs_log_commit_cil(mp, tp, &commit_lsn, flags); |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1402 | if (error == ENOMEM) { |
| 1403 | xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1404 | error = XFS_ERROR(EIO); |
| 1405 | goto out_unreserve; |
Dave Chinner | 0924378 | 2010-03-08 11:28:28 +1100 | [diff] [blame] | 1406 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1407 | |
Christoph Hellwig | 0244b96 | 2011-12-06 21:58:08 +0000 | [diff] [blame] | 1408 | current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); |
| 1409 | xfs_trans_free(tp); |
| 1410 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1411 | /* |
| 1412 | * If the transaction needs to be synchronous, then force the |
| 1413 | * log out now and wait for it. |
| 1414 | */ |
| 1415 | if (sync) { |
Christoph Hellwig | f538d4d | 2005-11-02 10:26:59 +1100 | [diff] [blame] | 1416 | if (!error) { |
Christoph Hellwig | a14a348 | 2010-01-19 09:56:46 +0000 | [diff] [blame] | 1417 | error = _xfs_log_force_lsn(mp, commit_lsn, |
Christoph Hellwig | b103705 | 2011-09-19 14:55:51 +0000 | [diff] [blame] | 1418 | XFS_LOG_SYNC, NULL); |
Christoph Hellwig | f538d4d | 2005-11-02 10:26:59 +1100 | [diff] [blame] | 1419 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1420 | XFS_STATS_INC(xs_trans_sync); |
| 1421 | } else { |
| 1422 | XFS_STATS_INC(xs_trans_async); |
| 1423 | } |
| 1424 | |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1425 | return error; |
| 1426 | |
| 1427 | out_unreserve: |
| 1428 | xfs_trans_unreserve_and_mod_sb(tp); |
| 1429 | |
| 1430 | /* |
| 1431 | * It is indeed possible for the transaction to be not dirty but |
| 1432 | * the dqinfo portion to be. All that means is that we have some |
| 1433 | * (non-persistent) quota reservations that need to be unreserved. |
| 1434 | */ |
| 1435 | xfs_trans_unreserve_and_mod_dquots(tp); |
| 1436 | if (tp->t_ticket) { |
| 1437 | commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, log_flags); |
| 1438 | if (commit_lsn == -1 && !error) |
| 1439 | error = XFS_ERROR(EIO); |
| 1440 | } |
| 1441 | current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); |
Dave Chinner | 71e330b | 2010-05-21 14:37:18 +1000 | [diff] [blame] | 1442 | xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0); |
Christoph Hellwig | a3ccd2c | 2010-03-15 12:52:49 +1100 | [diff] [blame] | 1443 | xfs_trans_free(tp); |
| 1444 | |
| 1445 | XFS_STATS_INC(xs_trans_empty); |
| 1446 | return error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1447 | } |
| 1448 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1449 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1450 | * Unlock all of the transaction's items and free the transaction. |
| 1451 | * The transaction must not have modified any of its items, because |
| 1452 | * there is no way to restore them to their previous state. |
| 1453 | * |
| 1454 | * If the transaction has made a log reservation, make sure to release |
| 1455 | * it as well. |
| 1456 | */ |
| 1457 | void |
| 1458 | xfs_trans_cancel( |
| 1459 | xfs_trans_t *tp, |
| 1460 | int flags) |
| 1461 | { |
| 1462 | int log_flags; |
Ryan Hankins | 0733af2 | 2006-01-11 15:36:44 +1100 | [diff] [blame] | 1463 | xfs_mount_t *mp = tp->t_mountp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1464 | |
| 1465 | /* |
| 1466 | * See if the caller is being too lazy to figure out if |
| 1467 | * the transaction really needs an abort. |
| 1468 | */ |
| 1469 | if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY)) |
| 1470 | flags &= ~XFS_TRANS_ABORT; |
| 1471 | /* |
| 1472 | * See if the caller is relying on us to shut down the |
| 1473 | * filesystem. This happens in paths where we detect |
| 1474 | * corruption and decide to give up. |
| 1475 | */ |
Nathan Scott | 60a204f | 2006-01-11 15:37:00 +1100 | [diff] [blame] | 1476 | if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) { |
Ryan Hankins | 0733af2 | 2006-01-11 15:36:44 +1100 | [diff] [blame] | 1477 | XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp); |
Nathan Scott | 7d04a33 | 2006-06-09 14:58:38 +1000 | [diff] [blame] | 1478 | xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); |
Nathan Scott | 60a204f | 2006-01-11 15:37:00 +1100 | [diff] [blame] | 1479 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1480 | #ifdef DEBUG |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 1481 | if (!(flags & XFS_TRANS_ABORT) && !XFS_FORCED_SHUTDOWN(mp)) { |
| 1482 | struct xfs_log_item_desc *lidp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1483 | |
Christoph Hellwig | e98c414 | 2010-06-23 18:11:15 +1000 | [diff] [blame] | 1484 | list_for_each_entry(lidp, &tp->t_items, lid_trans) |
| 1485 | ASSERT(!(lidp->lid_item->li_type == XFS_LI_EFD)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1486 | } |
| 1487 | #endif |
| 1488 | xfs_trans_unreserve_and_mod_sb(tp); |
Christoph Hellwig | 7d09525 | 2009-06-08 15:33:32 +0200 | [diff] [blame] | 1489 | xfs_trans_unreserve_and_mod_dquots(tp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1490 | |
| 1491 | if (tp->t_ticket) { |
| 1492 | if (flags & XFS_TRANS_RELEASE_LOG_RES) { |
| 1493 | ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); |
| 1494 | log_flags = XFS_LOG_REL_PERM_RESERV; |
| 1495 | } else { |
| 1496 | log_flags = 0; |
| 1497 | } |
Ryan Hankins | 0733af2 | 2006-01-11 15:36:44 +1100 | [diff] [blame] | 1498 | xfs_log_done(mp, tp->t_ticket, NULL, log_flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1499 | } |
| 1500 | |
| 1501 | /* mark this thread as no longer being in a transaction */ |
Nathan Scott | 59c1b08 | 2006-06-09 14:59:13 +1000 | [diff] [blame] | 1502 | current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1503 | |
Dave Chinner | 71e330b | 2010-05-21 14:37:18 +1000 | [diff] [blame] | 1504 | xfs_trans_free_items(tp, NULLCOMMITLSN, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1505 | xfs_trans_free(tp); |
| 1506 | } |
| 1507 | |
Niv Sardi | 322ff6b | 2008-08-13 16:05:49 +1000 | [diff] [blame] | 1508 | /* |
| 1509 | * Roll from one trans in the sequence of PERMANENT transactions to |
| 1510 | * the next: permanent transactions are only flushed out when |
| 1511 | * committed with XFS_TRANS_RELEASE_LOG_RES, but we still want as soon |
| 1512 | * as possible to let chunks of it go to the log. So we commit the |
| 1513 | * chunk we've been working on and get a new transaction to continue. |
| 1514 | */ |
| 1515 | int |
| 1516 | xfs_trans_roll( |
| 1517 | struct xfs_trans **tpp, |
| 1518 | struct xfs_inode *dp) |
| 1519 | { |
| 1520 | struct xfs_trans *trans; |
| 1521 | unsigned int logres, count; |
| 1522 | int error; |
| 1523 | |
| 1524 | /* |
| 1525 | * Ensure that the inode is always logged. |
| 1526 | */ |
| 1527 | trans = *tpp; |
| 1528 | xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE); |
| 1529 | |
| 1530 | /* |
| 1531 | * Copy the critical parameters from one trans to the next. |
| 1532 | */ |
| 1533 | logres = trans->t_log_res; |
| 1534 | count = trans->t_log_count; |
| 1535 | *tpp = xfs_trans_dup(trans); |
| 1536 | |
| 1537 | /* |
| 1538 | * Commit the current transaction. |
| 1539 | * If this commit failed, then it'd just unlock those items that |
| 1540 | * are not marked ihold. That also means that a filesystem shutdown |
| 1541 | * is in progress. The caller takes the responsibility to cancel |
| 1542 | * the duplicate transaction that gets returned. |
| 1543 | */ |
| 1544 | error = xfs_trans_commit(trans, 0); |
| 1545 | if (error) |
| 1546 | return (error); |
| 1547 | |
| 1548 | trans = *tpp; |
| 1549 | |
| 1550 | /* |
Dave Chinner | cc09c0d | 2008-11-17 17:37:10 +1100 | [diff] [blame] | 1551 | * transaction commit worked ok so we can drop the extra ticket |
| 1552 | * reference that we gained in xfs_trans_dup() |
| 1553 | */ |
| 1554 | xfs_log_ticket_put(trans->t_ticket); |
| 1555 | |
| 1556 | |
| 1557 | /* |
Niv Sardi | 322ff6b | 2008-08-13 16:05:49 +1000 | [diff] [blame] | 1558 | * Reserve space in the log for th next transaction. |
| 1559 | * This also pushes items in the "AIL", the list of logged items, |
| 1560 | * out to disk if they are taking up space at the tail of the log |
| 1561 | * that we want to use. This requires that either nothing be locked |
| 1562 | * across this call, or that anything that is locked be logged in |
| 1563 | * the prior and the next transactions. |
| 1564 | */ |
| 1565 | error = xfs_trans_reserve(trans, 0, logres, 0, |
| 1566 | XFS_TRANS_PERM_LOG_RES, count); |
| 1567 | /* |
| 1568 | * Ensure that the inode is in the new transaction and locked. |
| 1569 | */ |
| 1570 | if (error) |
| 1571 | return error; |
| 1572 | |
Christoph Hellwig | ddc3415 | 2011-09-19 15:00:54 +0000 | [diff] [blame] | 1573 | xfs_trans_ijoin(trans, dp, 0); |
Niv Sardi | 322ff6b | 2008-08-13 16:05:49 +1000 | [diff] [blame] | 1574 | return 0; |
| 1575 | } |