1/* 2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc. 3 * Copyright (C) 2010 Red Hat, Inc. 4 * All Rights Reserved. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation. 9 * 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. 14 * 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 18 */ 19#include "xfs.h" 20#include "xfs_fs.h" 21#include "xfs_types.h" 22#include "xfs_bit.h" 23#include "xfs_log.h" 24#include "xfs_inum.h" 25#include "xfs_trans.h" 26#include "xfs_sb.h" 27#include "xfs_ag.h" 28#include "xfs_mount.h" 29#include "xfs_error.h" 30#include "xfs_da_btree.h" 31#include "xfs_bmap_btree.h" 32#include "xfs_alloc_btree.h" 33#include "xfs_ialloc_btree.h" 34#include "xfs_dinode.h" 35#include "xfs_inode.h" 36#include "xfs_btree.h" 37#include "xfs_ialloc.h" 38#include "xfs_alloc.h" 39#include "xfs_bmap.h" 40#include "xfs_quota.h" 41#include "xfs_trans_priv.h" 42#include "xfs_trans_space.h" 43#include "xfs_inode_item.h" 44#include "xfs_trace.h" 45 46kmem_zone_t *xfs_trans_zone; 47kmem_zone_t *xfs_log_item_desc_zone; 48 49 50/* 51 * Various log reservation values. 52 * 53 * These are based on the size of the file system block because that is what 54 * most transactions manipulate. Each adds in an additional 128 bytes per 55 * item logged to try to account for the overhead of the transaction mechanism. 56 * 57 * Note: Most of the reservations underestimate the number of allocation 58 * groups into which they could free extents in the xfs_bmap_finish() call. 59 * This is because the number in the worst case is quite high and quite 60 * unusual. In order to fix this we need to change xfs_bmap_finish() to free 61 * extents in only a single AG at a time. This will require changes to the 62 * EFI code as well, however, so that the EFI for the extents not freed is 63 * logged again in each transaction. See SGI PV #261917. 64 * 65 * Reservation functions here avoid a huge stack in xfs_trans_init due to 66 * register overflow from temporaries in the calculations. 67 */ 68 69 70/* 71 * In a write transaction we can allocate a maximum of 2 72 * extents. This gives: 73 * the inode getting the new extents: inode size 74 * the inode's bmap btree: max depth * block size 75 * the agfs of the ags from which the extents are allocated: 2 * sector 76 * the superblock free block counter: sector size 77 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 78 * And the bmap_finish transaction can free bmap blocks in a join: 79 * the agfs of the ags containing the blocks: 2 * sector size 80 * the agfls of the ags containing the blocks: 2 * sector size 81 * the super block free block counter: sector size 82 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 83 */ 84STATIC uint 85xfs_calc_write_reservation( 86 struct xfs_mount *mp) 87{ 88 return XFS_DQUOT_LOGRES(mp) + 89 MAX((mp->m_sb.sb_inodesize + 90 XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) + 91 2 * mp->m_sb.sb_sectsize + 92 mp->m_sb.sb_sectsize + 93 XFS_ALLOCFREE_LOG_RES(mp, 2) + 94 128 * (4 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 95 XFS_ALLOCFREE_LOG_COUNT(mp, 2))), 96 (2 * mp->m_sb.sb_sectsize + 97 2 * mp->m_sb.sb_sectsize + 98 mp->m_sb.sb_sectsize + 99 XFS_ALLOCFREE_LOG_RES(mp, 2) + 100 128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2)))); 101} 102 103/* 104 * In truncating a file we free up to two extents at once. We can modify: 105 * the inode being truncated: inode size 106 * the inode's bmap btree: (max depth + 1) * block size 107 * And the bmap_finish transaction can free the blocks and bmap blocks: 108 * the agf for each of the ags: 4 * sector size 109 * the agfl for each of the ags: 4 * sector size 110 * the super block to reflect the freed blocks: sector size 111 * worst case split in allocation btrees per extent assuming 4 extents: 112 * 4 exts * 2 trees * (2 * max depth - 1) * block size 113 * the inode btree: max depth * blocksize 114 * the allocation btrees: 2 trees * (max depth - 1) * block size 115 */ 116STATIC uint 117xfs_calc_itruncate_reservation( 118 struct xfs_mount *mp) 119{ 120 return XFS_DQUOT_LOGRES(mp) + 121 MAX((mp->m_sb.sb_inodesize + 122 XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1) + 123 128 * (2 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))), 124 (4 * mp->m_sb.sb_sectsize + 125 4 * mp->m_sb.sb_sectsize + 126 mp->m_sb.sb_sectsize + 127 XFS_ALLOCFREE_LOG_RES(mp, 4) + 128 128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4)) + 129 128 * 5 + 130 XFS_ALLOCFREE_LOG_RES(mp, 1) + 131 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + 132 XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); 133} 134 135/* 136 * In renaming a files we can modify: 137 * the four inodes involved: 4 * inode size 138 * the two directory btrees: 2 * (max depth + v2) * dir block size 139 * the two directory bmap btrees: 2 * max depth * block size 140 * And the bmap_finish transaction can free dir and bmap blocks (two sets 141 * of bmap blocks) giving: 142 * the agf for the ags in which the blocks live: 3 * sector size 143 * the agfl for the ags in which the blocks live: 3 * sector size 144 * the superblock for the free block count: sector size 145 * the allocation btrees: 3 exts * 2 trees * (2 * max depth - 1) * block size 146 */ 147STATIC uint 148xfs_calc_rename_reservation( 149 struct xfs_mount *mp) 150{ 151 return XFS_DQUOT_LOGRES(mp) + 152 MAX((4 * mp->m_sb.sb_inodesize + 153 2 * XFS_DIROP_LOG_RES(mp) + 154 128 * (4 + 2 * XFS_DIROP_LOG_COUNT(mp))), 155 (3 * mp->m_sb.sb_sectsize + 156 3 * mp->m_sb.sb_sectsize + 157 mp->m_sb.sb_sectsize + 158 XFS_ALLOCFREE_LOG_RES(mp, 3) + 159 128 * (7 + XFS_ALLOCFREE_LOG_COUNT(mp, 3)))); 160} 161 162/* 163 * For creating a link to an inode: 164 * the parent directory inode: inode size 165 * the linked inode: inode size 166 * the directory btree could split: (max depth + v2) * dir block size 167 * the directory bmap btree could join or split: (max depth + v2) * blocksize 168 * And the bmap_finish transaction can free some bmap blocks giving: 169 * the agf for the ag in which the blocks live: sector size 170 * the agfl for the ag in which the blocks live: sector size 171 * the superblock for the free block count: sector size 172 * the allocation btrees: 2 trees * (2 * max depth - 1) * block size 173 */ 174STATIC uint 175xfs_calc_link_reservation( 176 struct xfs_mount *mp) 177{ 178 return XFS_DQUOT_LOGRES(mp) + 179 MAX((mp->m_sb.sb_inodesize + 180 mp->m_sb.sb_inodesize + 181 XFS_DIROP_LOG_RES(mp) + 182 128 * (2 + XFS_DIROP_LOG_COUNT(mp))), 183 (mp->m_sb.sb_sectsize + 184 mp->m_sb.sb_sectsize + 185 mp->m_sb.sb_sectsize + 186 XFS_ALLOCFREE_LOG_RES(mp, 1) + 187 128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); 188} 189 190/* 191 * For removing a directory entry we can modify: 192 * the parent directory inode: inode size 193 * the removed inode: inode size 194 * the directory btree could join: (max depth + v2) * dir block size 195 * the directory bmap btree could join or split: (max depth + v2) * blocksize 196 * And the bmap_finish transaction can free the dir and bmap blocks giving: 197 * the agf for the ag in which the blocks live: 2 * sector size 198 * the agfl for the ag in which the blocks live: 2 * sector size 199 * the superblock for the free block count: sector size 200 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 201 */ 202STATIC uint 203xfs_calc_remove_reservation( 204 struct xfs_mount *mp) 205{ 206 return XFS_DQUOT_LOGRES(mp) + 207 MAX((mp->m_sb.sb_inodesize + 208 mp->m_sb.sb_inodesize + 209 XFS_DIROP_LOG_RES(mp) + 210 128 * (2 + XFS_DIROP_LOG_COUNT(mp))), 211 (2 * mp->m_sb.sb_sectsize + 212 2 * mp->m_sb.sb_sectsize + 213 mp->m_sb.sb_sectsize + 214 XFS_ALLOCFREE_LOG_RES(mp, 2) + 215 128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2)))); 216} 217 218/* 219 * For symlink we can modify: 220 * the parent directory inode: inode size 221 * the new inode: inode size 222 * the inode btree entry: 1 block 223 * the directory btree: (max depth + v2) * dir block size 224 * the directory inode's bmap btree: (max depth + v2) * block size 225 * the blocks for the symlink: 1 kB 226 * Or in the first xact we allocate some inodes giving: 227 * the agi and agf of the ag getting the new inodes: 2 * sectorsize 228 * the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize 229 * the inode btree: max depth * blocksize 230 * the allocation btrees: 2 trees * (2 * max depth - 1) * block size 231 */ 232STATIC uint 233xfs_calc_symlink_reservation( 234 struct xfs_mount *mp) 235{ 236 return XFS_DQUOT_LOGRES(mp) + 237 MAX((mp->m_sb.sb_inodesize + 238 mp->m_sb.sb_inodesize + 239 XFS_FSB_TO_B(mp, 1) + 240 XFS_DIROP_LOG_RES(mp) + 241 1024 + 242 128 * (4 + XFS_DIROP_LOG_COUNT(mp))), 243 (2 * mp->m_sb.sb_sectsize + 244 XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) + 245 XFS_FSB_TO_B(mp, mp->m_in_maxlevels) + 246 XFS_ALLOCFREE_LOG_RES(mp, 1) + 247 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + 248 XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); 249} 250 251/* 252 * For create we can modify: 253 * the parent directory inode: inode size 254 * the new inode: inode size 255 * the inode btree entry: block size 256 * the superblock for the nlink flag: sector size 257 * the directory btree: (max depth + v2) * dir block size 258 * the directory inode's bmap btree: (max depth + v2) * block size 259 * Or in the first xact we allocate some inodes giving: 260 * the agi and agf of the ag getting the new inodes: 2 * sectorsize 261 * the superblock for the nlink flag: sector size 262 * the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize 263 * the inode btree: max depth * blocksize 264 * the allocation btrees: 2 trees * (max depth - 1) * block size 265 */ 266STATIC uint 267xfs_calc_create_reservation( 268 struct xfs_mount *mp) 269{ 270 return XFS_DQUOT_LOGRES(mp) + 271 MAX((mp->m_sb.sb_inodesize + 272 mp->m_sb.sb_inodesize + 273 mp->m_sb.sb_sectsize + 274 XFS_FSB_TO_B(mp, 1) + 275 XFS_DIROP_LOG_RES(mp) + 276 128 * (3 + XFS_DIROP_LOG_COUNT(mp))), 277 (3 * mp->m_sb.sb_sectsize + 278 XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) + 279 XFS_FSB_TO_B(mp, mp->m_in_maxlevels) + 280 XFS_ALLOCFREE_LOG_RES(mp, 1) + 281 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + 282 XFS_ALLOCFREE_LOG_COUNT(mp, 1)))); 283} 284 285/* 286 * Making a new directory is the same as creating a new file. 287 */ 288STATIC uint 289xfs_calc_mkdir_reservation( 290 struct xfs_mount *mp) 291{ 292 return xfs_calc_create_reservation(mp); 293} 294 295/* 296 * In freeing an inode we can modify: 297 * the inode being freed: inode size 298 * the super block free inode counter: sector size 299 * the agi hash list and counters: sector size 300 * the inode btree entry: block size 301 * the on disk inode before ours in the agi hash list: inode cluster size 302 * the inode btree: max depth * blocksize 303 * the allocation btrees: 2 trees * (max depth - 1) * block size 304 */ 305STATIC uint 306xfs_calc_ifree_reservation( 307 struct xfs_mount *mp) 308{ 309 return XFS_DQUOT_LOGRES(mp) + 310 mp->m_sb.sb_inodesize + 311 mp->m_sb.sb_sectsize + 312 mp->m_sb.sb_sectsize + 313 XFS_FSB_TO_B(mp, 1) + 314 MAX((__uint16_t)XFS_FSB_TO_B(mp, 1), 315 XFS_INODE_CLUSTER_SIZE(mp)) + 316 128 * 5 + 317 XFS_ALLOCFREE_LOG_RES(mp, 1) + 318 128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels + 319 XFS_ALLOCFREE_LOG_COUNT(mp, 1)); 320} 321 322/* 323 * When only changing the inode we log the inode and possibly the superblock 324 * We also add a bit of slop for the transaction stuff. 325 */ 326STATIC uint 327xfs_calc_ichange_reservation( 328 struct xfs_mount *mp) 329{ 330 return XFS_DQUOT_LOGRES(mp) + 331 mp->m_sb.sb_inodesize + 332 mp->m_sb.sb_sectsize + 333 512; 334 335} 336 337/* 338 * Growing the data section of the filesystem. 339 * superblock 340 * agi and agf 341 * allocation btrees 342 */ 343STATIC uint 344xfs_calc_growdata_reservation( 345 struct xfs_mount *mp) 346{ 347 return mp->m_sb.sb_sectsize * 3 + 348 XFS_ALLOCFREE_LOG_RES(mp, 1) + 349 128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1)); 350} 351 352/* 353 * Growing the rt section of the filesystem. 354 * In the first set of transactions (ALLOC) we allocate space to the 355 * bitmap or summary files. 356 * superblock: sector size 357 * agf of the ag from which the extent is allocated: sector size 358 * bmap btree for bitmap/summary inode: max depth * blocksize 359 * bitmap/summary inode: inode size 360 * allocation btrees for 1 block alloc: 2 * (2 * maxdepth - 1) * blocksize 361 */ 362STATIC uint 363xfs_calc_growrtalloc_reservation( 364 struct xfs_mount *mp) 365{ 366 return 2 * mp->m_sb.sb_sectsize + 367 XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) + 368 mp->m_sb.sb_inodesize + 369 XFS_ALLOCFREE_LOG_RES(mp, 1) + 370 128 * (3 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 371 XFS_ALLOCFREE_LOG_COUNT(mp, 1)); 372} 373 374/* 375 * Growing the rt section of the filesystem. 376 * In the second set of transactions (ZERO) we zero the new metadata blocks. 377 * one bitmap/summary block: blocksize 378 */ 379STATIC uint 380xfs_calc_growrtzero_reservation( 381 struct xfs_mount *mp) 382{ 383 return mp->m_sb.sb_blocksize + 128; 384} 385 386/* 387 * Growing the rt section of the filesystem. 388 * In the third set of transactions (FREE) we update metadata without 389 * allocating any new blocks. 390 * superblock: sector size 391 * bitmap inode: inode size 392 * summary inode: inode size 393 * one bitmap block: blocksize 394 * summary blocks: new summary size 395 */ 396STATIC uint 397xfs_calc_growrtfree_reservation( 398 struct xfs_mount *mp) 399{ 400 return mp->m_sb.sb_sectsize + 401 2 * mp->m_sb.sb_inodesize + 402 mp->m_sb.sb_blocksize + 403 mp->m_rsumsize + 404 128 * 5; 405} 406 407/* 408 * Logging the inode modification timestamp on a synchronous write. 409 * inode 410 */ 411STATIC uint 412xfs_calc_swrite_reservation( 413 struct xfs_mount *mp) 414{ 415 return mp->m_sb.sb_inodesize + 128; 416} 417 418/* 419 * Logging the inode mode bits when writing a setuid/setgid file 420 * inode 421 */ 422STATIC uint 423xfs_calc_writeid_reservation(xfs_mount_t *mp) 424{ 425 return mp->m_sb.sb_inodesize + 128; 426} 427 428/* 429 * Converting the inode from non-attributed to attributed. 430 * the inode being converted: inode size 431 * agf block and superblock (for block allocation) 432 * the new block (directory sized) 433 * bmap blocks for the new directory block 434 * allocation btrees 435 */ 436STATIC uint 437xfs_calc_addafork_reservation( 438 struct xfs_mount *mp) 439{ 440 return XFS_DQUOT_LOGRES(mp) + 441 mp->m_sb.sb_inodesize + 442 mp->m_sb.sb_sectsize * 2 + 443 mp->m_dirblksize + 444 XFS_FSB_TO_B(mp, XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) + 445 XFS_ALLOCFREE_LOG_RES(mp, 1) + 446 128 * (4 + XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1 + 447 XFS_ALLOCFREE_LOG_COUNT(mp, 1)); 448} 449 450/* 451 * Removing the attribute fork of a file 452 * the inode being truncated: inode size 453 * the inode's bmap btree: max depth * block size 454 * And the bmap_finish transaction can free the blocks and bmap blocks: 455 * the agf for each of the ags: 4 * sector size 456 * the agfl for each of the ags: 4 * sector size 457 * the super block to reflect the freed blocks: sector size 458 * worst case split in allocation btrees per extent assuming 4 extents: 459 * 4 exts * 2 trees * (2 * max depth - 1) * block size 460 */ 461STATIC uint 462xfs_calc_attrinval_reservation( 463 struct xfs_mount *mp) 464{ 465 return MAX((mp->m_sb.sb_inodesize + 466 XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) + 467 128 * (1 + XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK))), 468 (4 * mp->m_sb.sb_sectsize + 469 4 * mp->m_sb.sb_sectsize + 470 mp->m_sb.sb_sectsize + 471 XFS_ALLOCFREE_LOG_RES(mp, 4) + 472 128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4)))); 473} 474 475/* 476 * Setting an attribute. 477 * the inode getting the attribute 478 * the superblock for allocations 479 * the agfs extents are allocated from 480 * the attribute btree * max depth 481 * the inode allocation btree 482 * Since attribute transaction space is dependent on the size of the attribute, 483 * the calculation is done partially at mount time and partially at runtime. 484 */ 485STATIC uint 486xfs_calc_attrset_reservation( 487 struct xfs_mount *mp) 488{ 489 return XFS_DQUOT_LOGRES(mp) + 490 mp->m_sb.sb_inodesize + 491 mp->m_sb.sb_sectsize + 492 XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) + 493 128 * (2 + XFS_DA_NODE_MAXDEPTH); 494} 495 496/* 497 * Removing an attribute. 498 * the inode: inode size 499 * the attribute btree could join: max depth * block size 500 * the inode bmap btree could join or split: max depth * block size 501 * And the bmap_finish transaction can free the attr blocks freed giving: 502 * the agf for the ag in which the blocks live: 2 * sector size 503 * the agfl for the ag in which the blocks live: 2 * sector size 504 * the superblock for the free block count: sector size 505 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 506 */ 507STATIC uint 508xfs_calc_attrrm_reservation( 509 struct xfs_mount *mp) 510{ 511 return XFS_DQUOT_LOGRES(mp) + 512 MAX((mp->m_sb.sb_inodesize + 513 XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) + 514 XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) + 515 128 * (1 + XFS_DA_NODE_MAXDEPTH + 516 XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))), 517 (2 * mp->m_sb.sb_sectsize + 518 2 * mp->m_sb.sb_sectsize + 519 mp->m_sb.sb_sectsize + 520 XFS_ALLOCFREE_LOG_RES(mp, 2) + 521 128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2)))); 522} 523 524/* 525 * Clearing a bad agino number in an agi hash bucket. 526 */ 527STATIC uint 528xfs_calc_clear_agi_bucket_reservation( 529 struct xfs_mount *mp) 530{ 531 return mp->m_sb.sb_sectsize + 128; 532} 533 534/* 535 * Initialize the precomputed transaction reservation values 536 * in the mount structure. 537 */ 538void 539xfs_trans_init( 540 struct xfs_mount *mp) 541{ 542 struct xfs_trans_reservations *resp = &mp->m_reservations; 543 544 resp->tr_write = xfs_calc_write_reservation(mp); 545 resp->tr_itruncate = xfs_calc_itruncate_reservation(mp); 546 resp->tr_rename = xfs_calc_rename_reservation(mp); 547 resp->tr_link = xfs_calc_link_reservation(mp); 548 resp->tr_remove = xfs_calc_remove_reservation(mp); 549 resp->tr_symlink = xfs_calc_symlink_reservation(mp); 550 resp->tr_create = xfs_calc_create_reservation(mp); 551 resp->tr_mkdir = xfs_calc_mkdir_reservation(mp); 552 resp->tr_ifree = xfs_calc_ifree_reservation(mp); 553 resp->tr_ichange = xfs_calc_ichange_reservation(mp); 554 resp->tr_growdata = xfs_calc_growdata_reservation(mp); 555 resp->tr_swrite = xfs_calc_swrite_reservation(mp); 556 resp->tr_writeid = xfs_calc_writeid_reservation(mp); 557 resp->tr_addafork = xfs_calc_addafork_reservation(mp); 558 resp->tr_attrinval = xfs_calc_attrinval_reservation(mp); 559 resp->tr_attrset = xfs_calc_attrset_reservation(mp); 560 resp->tr_attrrm = xfs_calc_attrrm_reservation(mp); 561 resp->tr_clearagi = xfs_calc_clear_agi_bucket_reservation(mp); 562 resp->tr_growrtalloc = xfs_calc_growrtalloc_reservation(mp); 563 resp->tr_growrtzero = xfs_calc_growrtzero_reservation(mp); 564 resp->tr_growrtfree = xfs_calc_growrtfree_reservation(mp); 565} 566 567/* 568 * This routine is called to allocate a transaction structure. 569 * The type parameter indicates the type of the transaction. These 570 * are enumerated in xfs_trans.h. 571 * 572 * Dynamically allocate the transaction structure from the transaction 573 * zone, initialize it, and return it to the caller. 574 */ 575xfs_trans_t * 576xfs_trans_alloc( 577 xfs_mount_t *mp, 578 uint type) 579{ 580 xfs_wait_for_freeze(mp, SB_FREEZE_TRANS); 581 return _xfs_trans_alloc(mp, type, KM_SLEEP); 582} 583 584xfs_trans_t * 585_xfs_trans_alloc( 586 xfs_mount_t *mp, 587 uint type, 588 uint memflags) 589{ 590 xfs_trans_t *tp; 591 592 atomic_inc(&mp->m_active_trans); 593 594 tp = kmem_zone_zalloc(xfs_trans_zone, memflags); 595 tp->t_magic = XFS_TRANS_MAGIC; 596 tp->t_type = type; 597 tp->t_mountp = mp; 598 INIT_LIST_HEAD(&tp->t_items); 599 INIT_LIST_HEAD(&tp->t_busy); 600 return tp; 601} 602 603/* 604 * Free the transaction structure. If there is more clean up 605 * to do when the structure is freed, add it here. 606 */ 607STATIC void 608xfs_trans_free( 609 struct xfs_trans *tp) 610{ 611 struct xfs_busy_extent *busyp, *n; 612 613 list_for_each_entry_safe(busyp, n, &tp->t_busy, list) 614 xfs_alloc_busy_clear(tp->t_mountp, busyp); 615 616 atomic_dec(&tp->t_mountp->m_active_trans); 617 xfs_trans_free_dqinfo(tp); 618 kmem_zone_free(xfs_trans_zone, tp); 619} 620 621/* 622 * This is called to create a new transaction which will share the 623 * permanent log reservation of the given transaction. The remaining 624 * unused block and rt extent reservations are also inherited. This 625 * implies that the original transaction is no longer allowed to allocate 626 * blocks. Locks and log items, however, are no inherited. They must 627 * be added to the new transaction explicitly. 628 */ 629xfs_trans_t * 630xfs_trans_dup( 631 xfs_trans_t *tp) 632{ 633 xfs_trans_t *ntp; 634 635 ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP); 636 637 /* 638 * Initialize the new transaction structure. 639 */ 640 ntp->t_magic = XFS_TRANS_MAGIC; 641 ntp->t_type = tp->t_type; 642 ntp->t_mountp = tp->t_mountp; 643 INIT_LIST_HEAD(&ntp->t_items); 644 INIT_LIST_HEAD(&ntp->t_busy); 645 646 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 647 ASSERT(tp->t_ticket != NULL); 648 649 ntp->t_flags = XFS_TRANS_PERM_LOG_RES | (tp->t_flags & XFS_TRANS_RESERVE); 650 ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket); 651 ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used; 652 tp->t_blk_res = tp->t_blk_res_used; 653 ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used; 654 tp->t_rtx_res = tp->t_rtx_res_used; 655 ntp->t_pflags = tp->t_pflags; 656 657 xfs_trans_dup_dqinfo(tp, ntp); 658 659 atomic_inc(&tp->t_mountp->m_active_trans); 660 return ntp; 661} 662 663/* 664 * This is called to reserve free disk blocks and log space for the 665 * given transaction. This must be done before allocating any resources 666 * within the transaction. 667 * 668 * This will return ENOSPC if there are not enough blocks available. 669 * It will sleep waiting for available log space. 670 * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which 671 * is used by long running transactions. If any one of the reservations 672 * fails then they will all be backed out. 673 * 674 * This does not do quota reservations. That typically is done by the 675 * caller afterwards. 676 */ 677int 678xfs_trans_reserve( 679 xfs_trans_t *tp, 680 uint blocks, 681 uint logspace, 682 uint rtextents, 683 uint flags, 684 uint logcount) 685{ 686 int log_flags; 687 int error = 0; 688 int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; 689 690 /* Mark this thread as being in a transaction */ 691 current_set_flags_nested(&tp->t_pflags, PF_FSTRANS); 692 693 /* 694 * Attempt to reserve the needed disk blocks by decrementing 695 * the number needed from the number available. This will 696 * fail if the count would go below zero. 697 */ 698 if (blocks > 0) { 699 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS, 700 -((int64_t)blocks), rsvd); 701 if (error != 0) { 702 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 703 return (XFS_ERROR(ENOSPC)); 704 } 705 tp->t_blk_res += blocks; 706 } 707 708 /* 709 * Reserve the log space needed for this transaction. 710 */ 711 if (logspace > 0) { 712 ASSERT((tp->t_log_res == 0) || (tp->t_log_res == logspace)); 713 ASSERT((tp->t_log_count == 0) || 714 (tp->t_log_count == logcount)); 715 if (flags & XFS_TRANS_PERM_LOG_RES) { 716 log_flags = XFS_LOG_PERM_RESERV; 717 tp->t_flags |= XFS_TRANS_PERM_LOG_RES; 718 } else { 719 ASSERT(tp->t_ticket == NULL); 720 ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES)); 721 log_flags = 0; 722 } 723 724 error = xfs_log_reserve(tp->t_mountp, logspace, logcount, 725 &tp->t_ticket, 726 XFS_TRANSACTION, log_flags, tp->t_type); 727 if (error) { 728 goto undo_blocks; 729 } 730 tp->t_log_res = logspace; 731 tp->t_log_count = logcount; 732 } 733 734 /* 735 * Attempt to reserve the needed realtime extents by decrementing 736 * the number needed from the number available. This will 737 * fail if the count would go below zero. 738 */ 739 if (rtextents > 0) { 740 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS, 741 -((int64_t)rtextents), rsvd); 742 if (error) { 743 error = XFS_ERROR(ENOSPC); 744 goto undo_log; 745 } 746 tp->t_rtx_res += rtextents; 747 } 748 749 return 0; 750 751 /* 752 * Error cases jump to one of these labels to undo any 753 * reservations which have already been performed. 754 */ 755undo_log: 756 if (logspace > 0) { 757 if (flags & XFS_TRANS_PERM_LOG_RES) { 758 log_flags = XFS_LOG_REL_PERM_RESERV; 759 } else { 760 log_flags = 0; 761 } 762 xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags); 763 tp->t_ticket = NULL; 764 tp->t_log_res = 0; 765 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES; 766 } 767 768undo_blocks: 769 if (blocks > 0) { 770 (void) xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS, 771 (int64_t)blocks, rsvd); 772 tp->t_blk_res = 0; 773 } 774 775 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 776 777 return error; 778} 779 780/* 781 * Record the indicated change to the given field for application 782 * to the file system's superblock when the transaction commits. 783 * For now, just store the change in the transaction structure. 784 * 785 * Mark the transaction structure to indicate that the superblock 786 * needs to be updated before committing. 787 * 788 * Because we may not be keeping track of allocated/free inodes and 789 * used filesystem blocks in the superblock, we do not mark the 790 * superblock dirty in this transaction if we modify these fields. 791 * We still need to update the transaction deltas so that they get 792 * applied to the incore superblock, but we don't want them to 793 * cause the superblock to get locked and logged if these are the 794 * only fields in the superblock that the transaction modifies. 795 */ 796void 797xfs_trans_mod_sb( 798 xfs_trans_t *tp, 799 uint field, 800 int64_t delta) 801{ 802 uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY); 803 xfs_mount_t *mp = tp->t_mountp; 804 805 switch (field) { 806 case XFS_TRANS_SB_ICOUNT: 807 tp->t_icount_delta += delta; 808 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 809 flags &= ~XFS_TRANS_SB_DIRTY; 810 break; 811 case XFS_TRANS_SB_IFREE: 812 tp->t_ifree_delta += delta; 813 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 814 flags &= ~XFS_TRANS_SB_DIRTY; 815 break; 816 case XFS_TRANS_SB_FDBLOCKS: 817 /* 818 * Track the number of blocks allocated in the 819 * transaction. Make sure it does not exceed the 820 * number reserved. 821 */ 822 if (delta < 0) { 823 tp->t_blk_res_used += (uint)-delta; 824 ASSERT(tp->t_blk_res_used <= tp->t_blk_res); 825 } 826 tp->t_fdblocks_delta += delta; 827 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 828 flags &= ~XFS_TRANS_SB_DIRTY; 829 break; 830 case XFS_TRANS_SB_RES_FDBLOCKS: 831 /* 832 * The allocation has already been applied to the 833 * in-core superblock's counter. This should only 834 * be applied to the on-disk superblock. 835 */ 836 ASSERT(delta < 0); 837 tp->t_res_fdblocks_delta += delta; 838 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 839 flags &= ~XFS_TRANS_SB_DIRTY; 840 break; 841 case XFS_TRANS_SB_FREXTENTS: 842 /* 843 * Track the number of blocks allocated in the 844 * transaction. Make sure it does not exceed the 845 * number reserved. 846 */ 847 if (delta < 0) { 848 tp->t_rtx_res_used += (uint)-delta; 849 ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res); 850 } 851 tp->t_frextents_delta += delta; 852 break; 853 case XFS_TRANS_SB_RES_FREXTENTS: 854 /* 855 * The allocation has already been applied to the 856 * in-core superblock's counter. This should only 857 * be applied to the on-disk superblock. 858 */ 859 ASSERT(delta < 0); 860 tp->t_res_frextents_delta += delta; 861 break; 862 case XFS_TRANS_SB_DBLOCKS: 863 ASSERT(delta > 0); 864 tp->t_dblocks_delta += delta; 865 break; 866 case XFS_TRANS_SB_AGCOUNT: 867 ASSERT(delta > 0); 868 tp->t_agcount_delta += delta; 869 break; 870 case XFS_TRANS_SB_IMAXPCT: 871 tp->t_imaxpct_delta += delta; 872 break; 873 case XFS_TRANS_SB_REXTSIZE: 874 tp->t_rextsize_delta += delta; 875 break; 876 case XFS_TRANS_SB_RBMBLOCKS: 877 tp->t_rbmblocks_delta += delta; 878 break; 879 case XFS_TRANS_SB_RBLOCKS: 880 tp->t_rblocks_delta += delta; 881 break; 882 case XFS_TRANS_SB_REXTENTS: 883 tp->t_rextents_delta += delta; 884 break; 885 case XFS_TRANS_SB_REXTSLOG: 886 tp->t_rextslog_delta += delta; 887 break; 888 default: 889 ASSERT(0); 890 return; 891 } 892 893 tp->t_flags |= flags; 894} 895 896/* 897 * xfs_trans_apply_sb_deltas() is called from the commit code 898 * to bring the superblock buffer into the current transaction 899 * and modify it as requested by earlier calls to xfs_trans_mod_sb(). 900 * 901 * For now we just look at each field allowed to change and change 902 * it if necessary. 903 */ 904STATIC void 905xfs_trans_apply_sb_deltas( 906 xfs_trans_t *tp) 907{ 908 xfs_dsb_t *sbp; 909 xfs_buf_t *bp; 910 int whole = 0; 911 912 bp = xfs_trans_getsb(tp, tp->t_mountp, 0); 913 sbp = XFS_BUF_TO_SBP(bp); 914 915 /* 916 * Check that superblock mods match the mods made to AGF counters. 917 */ 918 ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) == 919 (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta + 920 tp->t_ag_btree_delta)); 921 922 /* 923 * Only update the superblock counters if we are logging them 924 */ 925 if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) { 926 if (tp->t_icount_delta) 927 be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta); 928 if (tp->t_ifree_delta) 929 be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta); 930 if (tp->t_fdblocks_delta) 931 be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta); 932 if (tp->t_res_fdblocks_delta) 933 be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta); 934 } 935 936 if (tp->t_frextents_delta) 937 be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta); 938 if (tp->t_res_frextents_delta) 939 be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta); 940 941 if (tp->t_dblocks_delta) { 942 be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta); 943 whole = 1; 944 } 945 if (tp->t_agcount_delta) { 946 be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta); 947 whole = 1; 948 } 949 if (tp->t_imaxpct_delta) { 950 sbp->sb_imax_pct += tp->t_imaxpct_delta; 951 whole = 1; 952 } 953 if (tp->t_rextsize_delta) { 954 be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta); 955 whole = 1; 956 } 957 if (tp->t_rbmblocks_delta) { 958 be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta); 959 whole = 1; 960 } 961 if (tp->t_rblocks_delta) { 962 be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta); 963 whole = 1; 964 } 965 if (tp->t_rextents_delta) { 966 be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta); 967 whole = 1; 968 } 969 if (tp->t_rextslog_delta) { 970 sbp->sb_rextslog += tp->t_rextslog_delta; 971 whole = 1; 972 } 973 974 if (whole) 975 /* 976 * Log the whole thing, the fields are noncontiguous. 977 */ 978 xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1); 979 else 980 /* 981 * Since all the modifiable fields are contiguous, we 982 * can get away with this. 983 */ 984 xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount), 985 offsetof(xfs_dsb_t, sb_frextents) + 986 sizeof(sbp->sb_frextents) - 1); 987} 988 989/* 990 * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations 991 * and apply superblock counter changes to the in-core superblock. The 992 * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT 993 * applied to the in-core superblock. The idea is that that has already been 994 * done. 995 * 996 * This is done efficiently with a single call to xfs_mod_incore_sb_batch(). 997 * However, we have to ensure that we only modify each superblock field only 998 * once because the application of the delta values may not be atomic. That can 999 * lead to ENOSPC races occurring if we have two separate modifcations of the 1000 * free space counter to put back the entire reservation and then take away 1001 * what we used. 1002 * 1003 * If we are not logging superblock counters, then the inode allocated/free and 1004 * used block counts are not updated in the on disk superblock. In this case, 1005 * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we 1006 * still need to update the incore superblock with the changes. 1007 */ 1008void 1009xfs_trans_unreserve_and_mod_sb( 1010 xfs_trans_t *tp) 1011{ 1012 xfs_mod_sb_t msb[14]; /* If you add cases, add entries */ 1013 xfs_mod_sb_t *msbp; 1014 xfs_mount_t *mp = tp->t_mountp; 1015 /* REFERENCED */ 1016 int error; 1017 int rsvd; 1018 int64_t blkdelta = 0; 1019 int64_t rtxdelta = 0; 1020 1021 msbp = msb; 1022 rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; 1023 1024 /* calculate free blocks delta */ 1025 if (tp->t_blk_res > 0) 1026 blkdelta = tp->t_blk_res; 1027 1028 if ((tp->t_fdblocks_delta != 0) && 1029 (xfs_sb_version_haslazysbcount(&mp->m_sb) || 1030 (tp->t_flags & XFS_TRANS_SB_DIRTY))) 1031 blkdelta += tp->t_fdblocks_delta; 1032 1033 if (blkdelta != 0) { 1034 msbp->msb_field = XFS_SBS_FDBLOCKS; 1035 msbp->msb_delta = blkdelta; 1036 msbp++; 1037 } 1038 1039 /* calculate free realtime extents delta */ 1040 if (tp->t_rtx_res > 0) 1041 rtxdelta = tp->t_rtx_res; 1042 1043 if ((tp->t_frextents_delta != 0) && 1044 (tp->t_flags & XFS_TRANS_SB_DIRTY)) 1045 rtxdelta += tp->t_frextents_delta; 1046 1047 if (rtxdelta != 0) { 1048 msbp->msb_field = XFS_SBS_FREXTENTS; 1049 msbp->msb_delta = rtxdelta; 1050 msbp++; 1051 } 1052 1053 /* apply remaining deltas */ 1054 1055 if (xfs_sb_version_haslazysbcount(&mp->m_sb) || 1056 (tp->t_flags & XFS_TRANS_SB_DIRTY)) { 1057 if (tp->t_icount_delta != 0) { 1058 msbp->msb_field = XFS_SBS_ICOUNT; 1059 msbp->msb_delta = tp->t_icount_delta; 1060 msbp++; 1061 } 1062 if (tp->t_ifree_delta != 0) { 1063 msbp->msb_field = XFS_SBS_IFREE; 1064 msbp->msb_delta = tp->t_ifree_delta; 1065 msbp++; 1066 } 1067 } 1068 1069 if (tp->t_flags & XFS_TRANS_SB_DIRTY) { 1070 if (tp->t_dblocks_delta != 0) { 1071 msbp->msb_field = XFS_SBS_DBLOCKS; 1072 msbp->msb_delta = tp->t_dblocks_delta; 1073 msbp++; 1074 } 1075 if (tp->t_agcount_delta != 0) { 1076 msbp->msb_field = XFS_SBS_AGCOUNT; 1077 msbp->msb_delta = tp->t_agcount_delta; 1078 msbp++; 1079 } 1080 if (tp->t_imaxpct_delta != 0) { 1081 msbp->msb_field = XFS_SBS_IMAX_PCT; 1082 msbp->msb_delta = tp->t_imaxpct_delta; 1083 msbp++; 1084 } 1085 if (tp->t_rextsize_delta != 0) { 1086 msbp->msb_field = XFS_SBS_REXTSIZE; 1087 msbp->msb_delta = tp->t_rextsize_delta; 1088 msbp++; 1089 } 1090 if (tp->t_rbmblocks_delta != 0) { 1091 msbp->msb_field = XFS_SBS_RBMBLOCKS; 1092 msbp->msb_delta = tp->t_rbmblocks_delta; 1093 msbp++; 1094 } 1095 if (tp->t_rblocks_delta != 0) { 1096 msbp->msb_field = XFS_SBS_RBLOCKS; 1097 msbp->msb_delta = tp->t_rblocks_delta; 1098 msbp++; 1099 } 1100 if (tp->t_rextents_delta != 0) { 1101 msbp->msb_field = XFS_SBS_REXTENTS; 1102 msbp->msb_delta = tp->t_rextents_delta; 1103 msbp++; 1104 } 1105 if (tp->t_rextslog_delta != 0) { 1106 msbp->msb_field = XFS_SBS_REXTSLOG; 1107 msbp->msb_delta = tp->t_rextslog_delta; 1108 msbp++; 1109 } 1110 } 1111 1112 /* 1113 * If we need to change anything, do it. 1114 */ 1115 if (msbp > msb) { 1116 error = xfs_mod_incore_sb_batch(tp->t_mountp, msb, 1117 (uint)(msbp - msb), rsvd); 1118 ASSERT(error == 0); 1119 } 1120} 1121 1122/* 1123 * Add the given log item to the transaction's list of log items. 1124 * 1125 * The log item will now point to its new descriptor with its li_desc field. 1126 */ 1127void 1128xfs_trans_add_item( 1129 struct xfs_trans *tp, 1130 struct xfs_log_item *lip) 1131{ 1132 struct xfs_log_item_desc *lidp; 1133 1134 ASSERT(lip->li_mountp = tp->t_mountp); 1135 ASSERT(lip->li_ailp = tp->t_mountp->m_ail); 1136 1137 lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS); 1138 1139 lidp->lid_item = lip; 1140 lidp->lid_flags = 0; 1141 lidp->lid_size = 0; 1142 list_add_tail(&lidp->lid_trans, &tp->t_items); 1143 1144 lip->li_desc = lidp; 1145} 1146 1147STATIC void 1148xfs_trans_free_item_desc( 1149 struct xfs_log_item_desc *lidp) 1150{ 1151 list_del_init(&lidp->lid_trans); 1152 kmem_zone_free(xfs_log_item_desc_zone, lidp); 1153} 1154 1155/* 1156 * Unlink and free the given descriptor. 1157 */ 1158void 1159xfs_trans_del_item( 1160 struct xfs_log_item *lip) 1161{ 1162 xfs_trans_free_item_desc(lip->li_desc); 1163 lip->li_desc = NULL; 1164} 1165 1166/* 1167 * Unlock all of the items of a transaction and free all the descriptors 1168 * of that transaction. 1169 */ 1170void 1171xfs_trans_free_items( 1172 struct xfs_trans *tp, 1173 xfs_lsn_t commit_lsn, 1174 int flags) 1175{ 1176 struct xfs_log_item_desc *lidp, *next; 1177 1178 list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) { 1179 struct xfs_log_item *lip = lidp->lid_item; 1180 1181 lip->li_desc = NULL; 1182 1183 if (commit_lsn != NULLCOMMITLSN) 1184 IOP_COMMITTING(lip, commit_lsn); 1185 if (flags & XFS_TRANS_ABORT) 1186 lip->li_flags |= XFS_LI_ABORTED; 1187 IOP_UNLOCK(lip); 1188 1189 xfs_trans_free_item_desc(lidp); 1190 } 1191} 1192 1193/* 1194 * Unlock the items associated with a transaction. 1195 * 1196 * Items which were not logged should be freed. Those which were logged must 1197 * still be tracked so they can be unpinned when the transaction commits. 1198 */ 1199STATIC void 1200xfs_trans_unlock_items( 1201 struct xfs_trans *tp, 1202 xfs_lsn_t commit_lsn) 1203{ 1204 struct xfs_log_item_desc *lidp, *next; 1205 1206 list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) { 1207 struct xfs_log_item *lip = lidp->lid_item; 1208 1209 lip->li_desc = NULL; 1210 1211 if (commit_lsn != NULLCOMMITLSN) 1212 IOP_COMMITTING(lip, commit_lsn); 1213 IOP_UNLOCK(lip); 1214 1215 /* 1216 * Free the descriptor if the item is not dirty 1217 * within this transaction. 1218 */ 1219 if (!(lidp->lid_flags & XFS_LID_DIRTY)) 1220 xfs_trans_free_item_desc(lidp); 1221 } 1222} 1223 1224/* 1225 * Total up the number of log iovecs needed to commit this 1226 * transaction. The transaction itself needs one for the 1227 * transaction header. Ask each dirty item in turn how many 1228 * it needs to get the total. 1229 */ 1230static uint 1231xfs_trans_count_vecs( 1232 struct xfs_trans *tp) 1233{ 1234 int nvecs; 1235 struct xfs_log_item_desc *lidp; 1236 1237 nvecs = 1; 1238 1239 /* In the non-debug case we need to start bailing out if we 1240 * didn't find a log_item here, return zero and let trans_commit 1241 * deal with it. 1242 */ 1243 if (list_empty(&tp->t_items)) { 1244 ASSERT(0); 1245 return 0; 1246 } 1247 1248 list_for_each_entry(lidp, &tp->t_items, lid_trans) { 1249 /* 1250 * Skip items which aren't dirty in this transaction. 1251 */ 1252 if (!(lidp->lid_flags & XFS_LID_DIRTY)) 1253 continue; 1254 lidp->lid_size = IOP_SIZE(lidp->lid_item); 1255 nvecs += lidp->lid_size; 1256 } 1257 1258 return nvecs; 1259} 1260 1261/* 1262 * Fill in the vector with pointers to data to be logged 1263 * by this transaction. The transaction header takes 1264 * the first vector, and then each dirty item takes the 1265 * number of vectors it indicated it needed in xfs_trans_count_vecs(). 1266 * 1267 * As each item fills in the entries it needs, also pin the item 1268 * so that it cannot be flushed out until the log write completes. 1269 */ 1270static void 1271xfs_trans_fill_vecs( 1272 struct xfs_trans *tp, 1273 struct xfs_log_iovec *log_vector) 1274{ 1275 struct xfs_log_item_desc *lidp; 1276 struct xfs_log_iovec *vecp; 1277 uint nitems; 1278 1279 /* 1280 * Skip over the entry for the transaction header, we'll 1281 * fill that in at the end. 1282 */ 1283 vecp = log_vector + 1; 1284 1285 nitems = 0; 1286 ASSERT(!list_empty(&tp->t_items)); 1287 list_for_each_entry(lidp, &tp->t_items, lid_trans) { 1288 /* Skip items which aren't dirty in this transaction. */ 1289 if (!(lidp->lid_flags & XFS_LID_DIRTY)) 1290 continue; 1291 1292 /* 1293 * The item may be marked dirty but not log anything. This can 1294 * be used to get called when a transaction is committed. 1295 */ 1296 if (lidp->lid_size) 1297 nitems++; 1298 IOP_FORMAT(lidp->lid_item, vecp); 1299 vecp += lidp->lid_size; 1300 IOP_PIN(lidp->lid_item); 1301 } 1302 1303 /* 1304 * Now that we've counted the number of items in this transaction, fill 1305 * in the transaction header. Note that the transaction header does not 1306 * have a log item. 1307 */ 1308 tp->t_header.th_magic = XFS_TRANS_HEADER_MAGIC; 1309 tp->t_header.th_type = tp->t_type; 1310 tp->t_header.th_num_items = nitems; 1311 log_vector->i_addr = (xfs_caddr_t)&tp->t_header; 1312 log_vector->i_len = sizeof(xfs_trans_header_t); 1313 log_vector->i_type = XLOG_REG_TYPE_TRANSHDR; 1314} 1315 1316/* 1317 * The committed item processing consists of calling the committed routine of 1318 * each logged item, updating the item's position in the AIL if necessary, and 1319 * unpinning each item. If the committed routine returns -1, then do nothing 1320 * further with the item because it may have been freed. 1321 * 1322 * Since items are unlocked when they are copied to the incore log, it is 1323 * possible for two transactions to be completing and manipulating the same 1324 * item simultaneously. The AIL lock will protect the lsn field of each item. 1325 * The value of this field can never go backwards. 1326 * 1327 * We unpin the items after repositioning them in the AIL, because otherwise 1328 * they could be immediately flushed and we'd have to race with the flusher 1329 * trying to pull the item from the AIL as we add it. 1330 */ 1331void 1332xfs_trans_item_committed( 1333 struct xfs_log_item *lip, 1334 xfs_lsn_t commit_lsn, 1335 int aborted) 1336{ 1337 xfs_lsn_t item_lsn; 1338 struct xfs_ail *ailp; 1339 1340 if (aborted) 1341 lip->li_flags |= XFS_LI_ABORTED; 1342 item_lsn = IOP_COMMITTED(lip, commit_lsn); 1343 1344 /* If the committed routine returns -1, item has been freed. */ 1345 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0) 1346 return; 1347 1348 /* 1349 * If the returned lsn is greater than what it contained before, update 1350 * the location of the item in the AIL. If it is not, then do nothing. 1351 * Items can never move backwards in the AIL. 1352 * 1353 * While the new lsn should usually be greater, it is possible that a 1354 * later transaction completing simultaneously with an earlier one 1355 * using the same item could complete first with a higher lsn. This 1356 * would cause the earlier transaction to fail the test below. 1357 */ 1358 ailp = lip->li_ailp; 1359 spin_lock(&ailp->xa_lock); 1360 if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) { 1361 /* 1362 * This will set the item's lsn to item_lsn and update the 1363 * position of the item in the AIL. 1364 * 1365 * xfs_trans_ail_update() drops the AIL lock. 1366 */ 1367 xfs_trans_ail_update(ailp, lip, item_lsn); 1368 } else { 1369 spin_unlock(&ailp->xa_lock); 1370 } 1371 1372 /* 1373 * Now that we've repositioned the item in the AIL, unpin it so it can 1374 * be flushed. Pass information about buffer stale state down from the 1375 * log item flags, if anyone else stales the buffer we do not want to 1376 * pay any attention to it. 1377 */ 1378 IOP_UNPIN(lip, 0); 1379} 1380 1381/* 1382 * This is typically called by the LM when a transaction has been fully 1383 * committed to disk. It needs to unpin the items which have 1384 * been logged by the transaction and update their positions 1385 * in the AIL if necessary. 1386 * 1387 * This also gets called when the transactions didn't get written out 1388 * because of an I/O error. Abortflag & XFS_LI_ABORTED is set then. 1389 */ 1390STATIC void 1391xfs_trans_committed( 1392 struct xfs_trans *tp, 1393 int abortflag) 1394{ 1395 struct xfs_log_item_desc *lidp, *next; 1396 1397 /* Call the transaction's completion callback if there is one. */ 1398 if (tp->t_callback != NULL) 1399 tp->t_callback(tp, tp->t_callarg); 1400 1401 list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) { 1402 xfs_trans_item_committed(lidp->lid_item, tp->t_lsn, abortflag); 1403 xfs_trans_free_item_desc(lidp); 1404 } 1405 1406 xfs_trans_free(tp); 1407} 1408 1409/* 1410 * Called from the trans_commit code when we notice that 1411 * the filesystem is in the middle of a forced shutdown. 1412 */ 1413STATIC void 1414xfs_trans_uncommit( 1415 struct xfs_trans *tp, 1416 uint flags) 1417{ 1418 struct xfs_log_item_desc *lidp; 1419 1420 list_for_each_entry(lidp, &tp->t_items, lid_trans) { 1421 /* 1422 * Unpin all but those that aren't dirty. 1423 */ 1424 if (lidp->lid_flags & XFS_LID_DIRTY) 1425 IOP_UNPIN(lidp->lid_item, 1); 1426 } 1427 1428 xfs_trans_unreserve_and_mod_sb(tp); 1429 xfs_trans_unreserve_and_mod_dquots(tp); 1430 1431 xfs_trans_free_items(tp, NULLCOMMITLSN, flags); 1432 xfs_trans_free(tp); 1433} 1434 1435/* 1436 * Format the transaction direct to the iclog. This isolates the physical 1437 * transaction commit operation from the logical operation and hence allows 1438 * other methods to be introduced without affecting the existing commit path. 1439 */ 1440static int 1441xfs_trans_commit_iclog( 1442 struct xfs_mount *mp, 1443 struct xfs_trans *tp, 1444 xfs_lsn_t *commit_lsn, 1445 int flags) 1446{ 1447 int shutdown; 1448 int error; 1449 int log_flags = 0; 1450 struct xlog_in_core *commit_iclog; 1451#define XFS_TRANS_LOGVEC_COUNT 16 1452 struct xfs_log_iovec log_vector_fast[XFS_TRANS_LOGVEC_COUNT]; 1453 struct xfs_log_iovec *log_vector; 1454 uint nvec; 1455 1456 1457 /* 1458 * Ask each log item how many log_vector entries it will 1459 * need so we can figure out how many to allocate. 1460 * Try to avoid the kmem_alloc() call in the common case 1461 * by using a vector from the stack when it fits. 1462 */ 1463 nvec = xfs_trans_count_vecs(tp); 1464 if (nvec == 0) { 1465 return ENOMEM; /* triggers a shutdown! */ 1466 } else if (nvec <= XFS_TRANS_LOGVEC_COUNT) { 1467 log_vector = log_vector_fast; 1468 } else { 1469 log_vector = (xfs_log_iovec_t *)kmem_alloc(nvec * 1470 sizeof(xfs_log_iovec_t), 1471 KM_SLEEP); 1472 } 1473 1474 /* 1475 * Fill in the log_vector and pin the logged items, and 1476 * then write the transaction to the log. 1477 */ 1478 xfs_trans_fill_vecs(tp, log_vector); 1479 1480 if (flags & XFS_TRANS_RELEASE_LOG_RES) 1481 log_flags = XFS_LOG_REL_PERM_RESERV; 1482 1483 error = xfs_log_write(mp, log_vector, nvec, tp->t_ticket, &(tp->t_lsn)); 1484 1485 /* 1486 * The transaction is committed incore here, and can go out to disk 1487 * at any time after this call. However, all the items associated 1488 * with the transaction are still locked and pinned in memory. 1489 */ 1490 *commit_lsn = xfs_log_done(mp, tp->t_ticket, &commit_iclog, log_flags); 1491 1492 tp->t_commit_lsn = *commit_lsn; 1493 trace_xfs_trans_commit_lsn(tp); 1494 1495 if (nvec > XFS_TRANS_LOGVEC_COUNT) 1496 kmem_free(log_vector); 1497 1498 /* 1499 * If we got a log write error. Unpin the logitems that we 1500 * had pinned, clean up, free trans structure, and return error. 1501 */ 1502 if (error || *commit_lsn == -1) { 1503 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 1504 xfs_trans_uncommit(tp, flags|XFS_TRANS_ABORT); 1505 return XFS_ERROR(EIO); 1506 } 1507 1508 /* 1509 * Once the transaction has committed, unused 1510 * reservations need to be released and changes to 1511 * the superblock need to be reflected in the in-core 1512 * version. Do that now. 1513 */ 1514 xfs_trans_unreserve_and_mod_sb(tp); 1515 1516 /* 1517 * Tell the LM to call the transaction completion routine 1518 * when the log write with LSN commit_lsn completes (e.g. 1519 * when the transaction commit really hits the on-disk log). 1520 * After this call we cannot reference tp, because the call 1521 * can happen at any time and the call will free the transaction 1522 * structure pointed to by tp. The only case where we call 1523 * the completion routine (xfs_trans_committed) directly is 1524 * if the log is turned off on a debug kernel or we're 1525 * running in simulation mode (the log is explicitly turned 1526 * off). 1527 */ 1528 tp->t_logcb.cb_func = (void(*)(void*, int))xfs_trans_committed; 1529 tp->t_logcb.cb_arg = tp; 1530 1531 /* 1532 * We need to pass the iclog buffer which was used for the 1533 * transaction commit record into this function, and attach 1534 * the callback to it. The callback must be attached before 1535 * the items are unlocked to avoid racing with other threads 1536 * waiting for an item to unlock. 1537 */ 1538 shutdown = xfs_log_notify(mp, commit_iclog, &(tp->t_logcb)); 1539 1540 /* 1541 * Mark this thread as no longer being in a transaction 1542 */ 1543 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 1544 1545 /* 1546 * Once all the items of the transaction have been copied 1547 * to the in core log and the callback is attached, the 1548 * items can be unlocked. 1549 * 1550 * This will free descriptors pointing to items which were 1551 * not logged since there is nothing more to do with them. 1552 * For items which were logged, we will keep pointers to them 1553 * so they can be unpinned after the transaction commits to disk. 1554 * This will also stamp each modified meta-data item with 1555 * the commit lsn of this transaction for dependency tracking 1556 * purposes. 1557 */ 1558 xfs_trans_unlock_items(tp, *commit_lsn); 1559 1560 /* 1561 * If we detected a log error earlier, finish committing 1562 * the transaction now (unpin log items, etc). 1563 * 1564 * Order is critical here, to avoid using the transaction 1565 * pointer after its been freed (by xfs_trans_committed 1566 * either here now, or as a callback). We cannot do this 1567 * step inside xfs_log_notify as was done earlier because 1568 * of this issue. 1569 */ 1570 if (shutdown) 1571 xfs_trans_committed(tp, XFS_LI_ABORTED); 1572 1573 /* 1574 * Now that the xfs_trans_committed callback has been attached, 1575 * and the items are released we can finally allow the iclog to 1576 * go to disk. 1577 */ 1578 return xfs_log_release_iclog(mp, commit_iclog); 1579} 1580 1581/* 1582 * Walk the log items and allocate log vector structures for 1583 * each item large enough to fit all the vectors they require. 1584 * Note that this format differs from the old log vector format in 1585 * that there is no transaction header in these log vectors. 1586 */ 1587STATIC struct xfs_log_vec * 1588xfs_trans_alloc_log_vecs( 1589 xfs_trans_t *tp) 1590{ 1591 struct xfs_log_item_desc *lidp; 1592 struct xfs_log_vec *lv = NULL; 1593 struct xfs_log_vec *ret_lv = NULL; 1594 1595 1596 /* Bail out if we didn't find a log item. */ 1597 if (list_empty(&tp->t_items)) { 1598 ASSERT(0); 1599 return NULL; 1600 } 1601 1602 list_for_each_entry(lidp, &tp->t_items, lid_trans) { 1603 struct xfs_log_vec *new_lv; 1604 1605 /* Skip items which aren't dirty in this transaction. */ 1606 if (!(lidp->lid_flags & XFS_LID_DIRTY)) 1607 continue; 1608 1609 /* Skip items that do not have any vectors for writing */ 1610 lidp->lid_size = IOP_SIZE(lidp->lid_item); 1611 if (!lidp->lid_size) 1612 continue; 1613 1614 new_lv = kmem_zalloc(sizeof(*new_lv) + 1615 lidp->lid_size * sizeof(struct xfs_log_iovec), 1616 KM_SLEEP); 1617 1618 /* The allocated iovec region lies beyond the log vector. */ 1619 new_lv->lv_iovecp = (struct xfs_log_iovec *)&new_lv[1]; 1620 new_lv->lv_niovecs = lidp->lid_size; 1621 new_lv->lv_item = lidp->lid_item; 1622 if (!ret_lv) 1623 ret_lv = new_lv; 1624 else 1625 lv->lv_next = new_lv; 1626 lv = new_lv; 1627 } 1628 1629 return ret_lv; 1630} 1631 1632static int 1633xfs_trans_commit_cil( 1634 struct xfs_mount *mp, 1635 struct xfs_trans *tp, 1636 xfs_lsn_t *commit_lsn, 1637 int flags) 1638{ 1639 struct xfs_log_vec *log_vector; 1640 int error; 1641 1642 /* 1643 * Get each log item to allocate a vector structure for 1644 * the log item to to pass to the log write code. The 1645 * CIL commit code will format the vector and save it away. 1646 */ 1647 log_vector = xfs_trans_alloc_log_vecs(tp); 1648 if (!log_vector) 1649 return ENOMEM; 1650 1651 error = xfs_log_commit_cil(mp, tp, log_vector, commit_lsn, flags); 1652 if (error) 1653 return error; 1654 1655 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 1656 xfs_trans_free(tp); 1657 return 0; 1658} 1659 1660/* 1661 * xfs_trans_commit 1662 * 1663 * Commit the given transaction to the log a/synchronously. 1664 * 1665 * XFS disk error handling mechanism is not based on a typical 1666 * transaction abort mechanism. Logically after the filesystem 1667 * gets marked 'SHUTDOWN', we can't let any new transactions 1668 * be durable - ie. committed to disk - because some metadata might 1669 * be inconsistent. In such cases, this returns an error, and the 1670 * caller may assume that all locked objects joined to the transaction 1671 * have already been unlocked as if the commit had succeeded. 1672 * Do not reference the transaction structure after this call. 1673 */ 1674int 1675_xfs_trans_commit( 1676 struct xfs_trans *tp, 1677 uint flags, 1678 int *log_flushed) 1679{ 1680 struct xfs_mount *mp = tp->t_mountp; 1681 xfs_lsn_t commit_lsn = -1; 1682 int error = 0; 1683 int log_flags = 0; 1684 int sync = tp->t_flags & XFS_TRANS_SYNC; 1685 1686 /* 1687 * Determine whether this commit is releasing a permanent 1688 * log reservation or not. 1689 */ 1690 if (flags & XFS_TRANS_RELEASE_LOG_RES) { 1691 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 1692 log_flags = XFS_LOG_REL_PERM_RESERV; 1693 } 1694 1695 /* 1696 * If there is nothing to be logged by the transaction, 1697 * then unlock all of the items associated with the 1698 * transaction and free the transaction structure. 1699 * Also make sure to return any reserved blocks to 1700 * the free pool. 1701 */ 1702 if (!(tp->t_flags & XFS_TRANS_DIRTY)) 1703 goto out_unreserve; 1704 1705 if (XFS_FORCED_SHUTDOWN(mp)) { 1706 error = XFS_ERROR(EIO); 1707 goto out_unreserve; 1708 } 1709 1710 ASSERT(tp->t_ticket != NULL); 1711 1712 /* 1713 * If we need to update the superblock, then do it now. 1714 */ 1715 if (tp->t_flags & XFS_TRANS_SB_DIRTY) 1716 xfs_trans_apply_sb_deltas(tp); 1717 xfs_trans_apply_dquot_deltas(tp); 1718 1719 if (mp->m_flags & XFS_MOUNT_DELAYLOG) 1720 error = xfs_trans_commit_cil(mp, tp, &commit_lsn, flags); 1721 else 1722 error = xfs_trans_commit_iclog(mp, tp, &commit_lsn, flags); 1723 1724 if (error == ENOMEM) { 1725 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); 1726 error = XFS_ERROR(EIO); 1727 goto out_unreserve; 1728 } 1729 1730 /* 1731 * If the transaction needs to be synchronous, then force the 1732 * log out now and wait for it. 1733 */ 1734 if (sync) { 1735 if (!error) { 1736 error = _xfs_log_force_lsn(mp, commit_lsn, 1737 XFS_LOG_SYNC, log_flushed); 1738 } 1739 XFS_STATS_INC(xs_trans_sync); 1740 } else { 1741 XFS_STATS_INC(xs_trans_async); 1742 } 1743 1744 return error; 1745 1746out_unreserve: 1747 xfs_trans_unreserve_and_mod_sb(tp); 1748 1749 /* 1750 * It is indeed possible for the transaction to be not dirty but 1751 * the dqinfo portion to be. All that means is that we have some 1752 * (non-persistent) quota reservations that need to be unreserved. 1753 */ 1754 xfs_trans_unreserve_and_mod_dquots(tp); 1755 if (tp->t_ticket) { 1756 commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, log_flags); 1757 if (commit_lsn == -1 && !error) 1758 error = XFS_ERROR(EIO); 1759 } 1760 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 1761 xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0); 1762 xfs_trans_free(tp); 1763 1764 XFS_STATS_INC(xs_trans_empty); 1765 return error; 1766} 1767 1768/* 1769 * Unlock all of the transaction's items and free the transaction. 1770 * The transaction must not have modified any of its items, because 1771 * there is no way to restore them to their previous state. 1772 * 1773 * If the transaction has made a log reservation, make sure to release 1774 * it as well. 1775 */ 1776void 1777xfs_trans_cancel( 1778 xfs_trans_t *tp, 1779 int flags) 1780{ 1781 int log_flags; 1782 xfs_mount_t *mp = tp->t_mountp; 1783 1784 /* 1785 * See if the caller is being too lazy to figure out if 1786 * the transaction really needs an abort. 1787 */ 1788 if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY)) 1789 flags &= ~XFS_TRANS_ABORT; 1790 /* 1791 * See if the caller is relying on us to shut down the 1792 * filesystem. This happens in paths where we detect 1793 * corruption and decide to give up. 1794 */ 1795 if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) { 1796 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp); 1797 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1798 } 1799#ifdef DEBUG 1800 if (!(flags & XFS_TRANS_ABORT) && !XFS_FORCED_SHUTDOWN(mp)) { 1801 struct xfs_log_item_desc *lidp; 1802 1803 list_for_each_entry(lidp, &tp->t_items, lid_trans) 1804 ASSERT(!(lidp->lid_item->li_type == XFS_LI_EFD)); 1805 } 1806#endif 1807 xfs_trans_unreserve_and_mod_sb(tp); 1808 xfs_trans_unreserve_and_mod_dquots(tp); 1809 1810 if (tp->t_ticket) { 1811 if (flags & XFS_TRANS_RELEASE_LOG_RES) { 1812 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 1813 log_flags = XFS_LOG_REL_PERM_RESERV; 1814 } else { 1815 log_flags = 0; 1816 } 1817 xfs_log_done(mp, tp->t_ticket, NULL, log_flags); 1818 } 1819 1820 /* mark this thread as no longer being in a transaction */ 1821 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 1822 1823 xfs_trans_free_items(tp, NULLCOMMITLSN, flags); 1824 xfs_trans_free(tp); 1825} 1826 1827/* 1828 * Roll from one trans in the sequence of PERMANENT transactions to 1829 * the next: permanent transactions are only flushed out when 1830 * committed with XFS_TRANS_RELEASE_LOG_RES, but we still want as soon 1831 * as possible to let chunks of it go to the log. So we commit the 1832 * chunk we've been working on and get a new transaction to continue. 1833 */ 1834int 1835xfs_trans_roll( 1836 struct xfs_trans **tpp, 1837 struct xfs_inode *dp) 1838{ 1839 struct xfs_trans *trans; 1840 unsigned int logres, count; 1841 int error; 1842 1843 /* 1844 * Ensure that the inode is always logged. 1845 */ 1846 trans = *tpp; 1847 xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE); 1848 1849 /* 1850 * Copy the critical parameters from one trans to the next. 1851 */ 1852 logres = trans->t_log_res; 1853 count = trans->t_log_count; 1854 *tpp = xfs_trans_dup(trans); 1855 1856 /* 1857 * Commit the current transaction. 1858 * If this commit failed, then it'd just unlock those items that 1859 * are not marked ihold. That also means that a filesystem shutdown 1860 * is in progress. The caller takes the responsibility to cancel 1861 * the duplicate transaction that gets returned. 1862 */ 1863 error = xfs_trans_commit(trans, 0); 1864 if (error) 1865 return (error); 1866 1867 trans = *tpp; 1868 1869 /* 1870 * transaction commit worked ok so we can drop the extra ticket 1871 * reference that we gained in xfs_trans_dup() 1872 */ 1873 xfs_log_ticket_put(trans->t_ticket); 1874 1875 1876 /* 1877 * Reserve space in the log for th next transaction. 1878 * This also pushes items in the "AIL", the list of logged items, 1879 * out to disk if they are taking up space at the tail of the log 1880 * that we want to use. This requires that either nothing be locked 1881 * across this call, or that anything that is locked be logged in 1882 * the prior and the next transactions. 1883 */ 1884 error = xfs_trans_reserve(trans, 0, logres, 0, 1885 XFS_TRANS_PERM_LOG_RES, count); 1886 /* 1887 * Ensure that the inode is in the new transaction and locked. 1888 */ 1889 if (error) 1890 return error; 1891 1892 xfs_trans_ijoin(trans, dp); 1893 return 0; 1894} 1895