1/* 2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18#include "xfs.h" 19#include "xfs_fs.h" 20#include "xfs_types.h" 21#include "xfs_bit.h" 22#include "xfs_log.h" 23#include "xfs_inum.h" 24#include "xfs_trans.h" 25#include "xfs_sb.h" 26#include "xfs_ag.h" 27#include "xfs_mount.h" 28#include "xfs_trans_priv.h" 29#include "xfs_bmap_btree.h" 30#include "xfs_dinode.h" 31#include "xfs_inode.h" 32#include "xfs_inode_item.h" 33#include "xfs_error.h" 34#include "xfs_trace.h" 35 36 37kmem_zone_t *xfs_ili_zone; /* inode log item zone */ 38 39static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip) 40{ 41 return container_of(lip, struct xfs_inode_log_item, ili_item); 42} 43 44 45/* 46 * This returns the number of iovecs needed to log the given inode item. 47 * 48 * We need one iovec for the inode log format structure, one for the 49 * inode core, and possibly one for the inode data/extents/b-tree root 50 * and one for the inode attribute data/extents/b-tree root. 51 */ 52STATIC uint 53xfs_inode_item_size( 54 struct xfs_log_item *lip) 55{ 56 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 57 struct xfs_inode *ip = iip->ili_inode; 58 uint nvecs = 2; 59 60 /* 61 * Only log the data/extents/b-tree root if there is something 62 * left to log. 63 */ 64 iip->ili_format.ilf_fields |= XFS_ILOG_CORE; 65 66 switch (ip->i_d.di_format) { 67 case XFS_DINODE_FMT_EXTENTS: 68 iip->ili_format.ilf_fields &= 69 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | 70 XFS_ILOG_DEV | XFS_ILOG_UUID); 71 if ((iip->ili_format.ilf_fields & XFS_ILOG_DEXT) && 72 (ip->i_d.di_nextents > 0) && 73 (ip->i_df.if_bytes > 0)) { 74 ASSERT(ip->i_df.if_u1.if_extents != NULL); 75 nvecs++; 76 } else { 77 iip->ili_format.ilf_fields &= ~XFS_ILOG_DEXT; 78 } 79 break; 80 81 case XFS_DINODE_FMT_BTREE: 82 ASSERT(ip->i_df.if_ext_max == 83 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t)); 84 iip->ili_format.ilf_fields &= 85 ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT | 86 XFS_ILOG_DEV | XFS_ILOG_UUID); 87 if ((iip->ili_format.ilf_fields & XFS_ILOG_DBROOT) && 88 (ip->i_df.if_broot_bytes > 0)) { 89 ASSERT(ip->i_df.if_broot != NULL); 90 nvecs++; 91 } else { 92 ASSERT(!(iip->ili_format.ilf_fields & 93 XFS_ILOG_DBROOT)); 94#ifdef XFS_TRANS_DEBUG 95 if (iip->ili_root_size > 0) { 96 ASSERT(iip->ili_root_size == 97 ip->i_df.if_broot_bytes); 98 ASSERT(memcmp(iip->ili_orig_root, 99 ip->i_df.if_broot, 100 iip->ili_root_size) == 0); 101 } else { 102 ASSERT(ip->i_df.if_broot_bytes == 0); 103 } 104#endif 105 iip->ili_format.ilf_fields &= ~XFS_ILOG_DBROOT; 106 } 107 break; 108 109 case XFS_DINODE_FMT_LOCAL: 110 iip->ili_format.ilf_fields &= 111 ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT | 112 XFS_ILOG_DEV | XFS_ILOG_UUID); 113 if ((iip->ili_format.ilf_fields & XFS_ILOG_DDATA) && 114 (ip->i_df.if_bytes > 0)) { 115 ASSERT(ip->i_df.if_u1.if_data != NULL); 116 ASSERT(ip->i_d.di_size > 0); 117 nvecs++; 118 } else { 119 iip->ili_format.ilf_fields &= ~XFS_ILOG_DDATA; 120 } 121 break; 122 123 case XFS_DINODE_FMT_DEV: 124 iip->ili_format.ilf_fields &= 125 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | 126 XFS_ILOG_DEXT | XFS_ILOG_UUID); 127 break; 128 129 case XFS_DINODE_FMT_UUID: 130 iip->ili_format.ilf_fields &= 131 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | 132 XFS_ILOG_DEXT | XFS_ILOG_DEV); 133 break; 134 135 default: 136 ASSERT(0); 137 break; 138 } 139 140 /* 141 * If there are no attributes associated with this file, 142 * then there cannot be anything more to log. 143 * Clear all attribute-related log flags. 144 */ 145 if (!XFS_IFORK_Q(ip)) { 146 iip->ili_format.ilf_fields &= 147 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT); 148 return nvecs; 149 } 150 151 /* 152 * Log any necessary attribute data. 153 */ 154 switch (ip->i_d.di_aformat) { 155 case XFS_DINODE_FMT_EXTENTS: 156 iip->ili_format.ilf_fields &= 157 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT); 158 if ((iip->ili_format.ilf_fields & XFS_ILOG_AEXT) && 159 (ip->i_d.di_anextents > 0) && 160 (ip->i_afp->if_bytes > 0)) { 161 ASSERT(ip->i_afp->if_u1.if_extents != NULL); 162 nvecs++; 163 } else { 164 iip->ili_format.ilf_fields &= ~XFS_ILOG_AEXT; 165 } 166 break; 167 168 case XFS_DINODE_FMT_BTREE: 169 iip->ili_format.ilf_fields &= 170 ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT); 171 if ((iip->ili_format.ilf_fields & XFS_ILOG_ABROOT) && 172 (ip->i_afp->if_broot_bytes > 0)) { 173 ASSERT(ip->i_afp->if_broot != NULL); 174 nvecs++; 175 } else { 176 iip->ili_format.ilf_fields &= ~XFS_ILOG_ABROOT; 177 } 178 break; 179 180 case XFS_DINODE_FMT_LOCAL: 181 iip->ili_format.ilf_fields &= 182 ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT); 183 if ((iip->ili_format.ilf_fields & XFS_ILOG_ADATA) && 184 (ip->i_afp->if_bytes > 0)) { 185 ASSERT(ip->i_afp->if_u1.if_data != NULL); 186 nvecs++; 187 } else { 188 iip->ili_format.ilf_fields &= ~XFS_ILOG_ADATA; 189 } 190 break; 191 192 default: 193 ASSERT(0); 194 break; 195 } 196 197 return nvecs; 198} 199 200/* 201 * This is called to fill in the vector of log iovecs for the 202 * given inode log item. It fills the first item with an inode 203 * log format structure, the second with the on-disk inode structure, 204 * and a possible third and/or fourth with the inode data/extents/b-tree 205 * root and inode attributes data/extents/b-tree root. 206 */ 207STATIC void 208xfs_inode_item_format( 209 struct xfs_log_item *lip, 210 struct xfs_log_iovec *vecp) 211{ 212 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 213 struct xfs_inode *ip = iip->ili_inode; 214 uint nvecs; 215 size_t data_bytes; 216 xfs_bmbt_rec_t *ext_buffer; 217 xfs_mount_t *mp; 218 219 vecp->i_addr = &iip->ili_format; 220 vecp->i_len = sizeof(xfs_inode_log_format_t); 221 vecp->i_type = XLOG_REG_TYPE_IFORMAT; 222 vecp++; 223 nvecs = 1; 224 225 /* 226 * Make sure the linux inode is dirty. We do this before 227 * clearing i_update_core as the VFS will call back into 228 * XFS here and set i_update_core, so we need to dirty the 229 * inode first so that the ordering of i_update_core and 230 * unlogged modifications still works as described below. 231 */ 232 xfs_mark_inode_dirty_sync(ip); 233 234 /* 235 * Clear i_update_core if the timestamps (or any other 236 * non-transactional modification) need flushing/logging 237 * and we're about to log them with the rest of the core. 238 * 239 * This is the same logic as xfs_iflush() but this code can't 240 * run at the same time as xfs_iflush because we're in commit 241 * processing here and so we have the inode lock held in 242 * exclusive mode. Although it doesn't really matter 243 * for the timestamps if both routines were to grab the 244 * timestamps or not. That would be ok. 245 * 246 * We clear i_update_core before copying out the data. 247 * This is for coordination with our timestamp updates 248 * that don't hold the inode lock. They will always 249 * update the timestamps BEFORE setting i_update_core, 250 * so if we clear i_update_core after they set it we 251 * are guaranteed to see their updates to the timestamps 252 * either here. Likewise, if they set it after we clear it 253 * here, we'll see it either on the next commit of this 254 * inode or the next time the inode gets flushed via 255 * xfs_iflush(). This depends on strongly ordered memory 256 * semantics, but we have that. We use the SYNCHRONIZE 257 * macro to make sure that the compiler does not reorder 258 * the i_update_core access below the data copy below. 259 */ 260 if (ip->i_update_core) { 261 ip->i_update_core = 0; 262 SYNCHRONIZE(); 263 } 264 265 /* 266 * Make sure to get the latest timestamps from the Linux inode. 267 */ 268 xfs_synchronize_times(ip); 269 270 vecp->i_addr = &ip->i_d; 271 vecp->i_len = sizeof(struct xfs_icdinode); 272 vecp->i_type = XLOG_REG_TYPE_ICORE; 273 vecp++; 274 nvecs++; 275 iip->ili_format.ilf_fields |= XFS_ILOG_CORE; 276 277 /* 278 * If this is really an old format inode, then we need to 279 * log it as such. This means that we have to copy the link 280 * count from the new field to the old. We don't have to worry 281 * about the new fields, because nothing trusts them as long as 282 * the old inode version number is there. If the superblock already 283 * has a new version number, then we don't bother converting back. 284 */ 285 mp = ip->i_mount; 286 ASSERT(ip->i_d.di_version == 1 || xfs_sb_version_hasnlink(&mp->m_sb)); 287 if (ip->i_d.di_version == 1) { 288 if (!xfs_sb_version_hasnlink(&mp->m_sb)) { 289 /* 290 * Convert it back. 291 */ 292 ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1); 293 ip->i_d.di_onlink = ip->i_d.di_nlink; 294 } else { 295 /* 296 * The superblock version has already been bumped, 297 * so just make the conversion to the new inode 298 * format permanent. 299 */ 300 ip->i_d.di_version = 2; 301 ip->i_d.di_onlink = 0; 302 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad)); 303 } 304 } 305 306 switch (ip->i_d.di_format) { 307 case XFS_DINODE_FMT_EXTENTS: 308 ASSERT(!(iip->ili_format.ilf_fields & 309 (XFS_ILOG_DDATA | XFS_ILOG_DBROOT | 310 XFS_ILOG_DEV | XFS_ILOG_UUID))); 311 if (iip->ili_format.ilf_fields & XFS_ILOG_DEXT) { 312 ASSERT(ip->i_df.if_bytes > 0); 313 ASSERT(ip->i_df.if_u1.if_extents != NULL); 314 ASSERT(ip->i_d.di_nextents > 0); 315 ASSERT(iip->ili_extents_buf == NULL); 316 ASSERT((ip->i_df.if_bytes / 317 (uint)sizeof(xfs_bmbt_rec_t)) > 0); 318#ifdef XFS_NATIVE_HOST 319 if (ip->i_d.di_nextents == ip->i_df.if_bytes / 320 (uint)sizeof(xfs_bmbt_rec_t)) { 321 /* 322 * There are no delayed allocation 323 * extents, so just point to the 324 * real extents array. 325 */ 326 vecp->i_addr = ip->i_df.if_u1.if_extents; 327 vecp->i_len = ip->i_df.if_bytes; 328 vecp->i_type = XLOG_REG_TYPE_IEXT; 329 } else 330#endif 331 { 332 /* 333 * There are delayed allocation extents 334 * in the inode, or we need to convert 335 * the extents to on disk format. 336 * Use xfs_iextents_copy() 337 * to copy only the real extents into 338 * a separate buffer. We'll free the 339 * buffer in the unlock routine. 340 */ 341 ext_buffer = kmem_alloc(ip->i_df.if_bytes, 342 KM_SLEEP); 343 iip->ili_extents_buf = ext_buffer; 344 vecp->i_addr = ext_buffer; 345 vecp->i_len = xfs_iextents_copy(ip, ext_buffer, 346 XFS_DATA_FORK); 347 vecp->i_type = XLOG_REG_TYPE_IEXT; 348 } 349 ASSERT(vecp->i_len <= ip->i_df.if_bytes); 350 iip->ili_format.ilf_dsize = vecp->i_len; 351 vecp++; 352 nvecs++; 353 } 354 break; 355 356 case XFS_DINODE_FMT_BTREE: 357 ASSERT(!(iip->ili_format.ilf_fields & 358 (XFS_ILOG_DDATA | XFS_ILOG_DEXT | 359 XFS_ILOG_DEV | XFS_ILOG_UUID))); 360 if (iip->ili_format.ilf_fields & XFS_ILOG_DBROOT) { 361 ASSERT(ip->i_df.if_broot_bytes > 0); 362 ASSERT(ip->i_df.if_broot != NULL); 363 vecp->i_addr = ip->i_df.if_broot; 364 vecp->i_len = ip->i_df.if_broot_bytes; 365 vecp->i_type = XLOG_REG_TYPE_IBROOT; 366 vecp++; 367 nvecs++; 368 iip->ili_format.ilf_dsize = ip->i_df.if_broot_bytes; 369 } 370 break; 371 372 case XFS_DINODE_FMT_LOCAL: 373 ASSERT(!(iip->ili_format.ilf_fields & 374 (XFS_ILOG_DBROOT | XFS_ILOG_DEXT | 375 XFS_ILOG_DEV | XFS_ILOG_UUID))); 376 if (iip->ili_format.ilf_fields & XFS_ILOG_DDATA) { 377 ASSERT(ip->i_df.if_bytes > 0); 378 ASSERT(ip->i_df.if_u1.if_data != NULL); 379 ASSERT(ip->i_d.di_size > 0); 380 381 vecp->i_addr = ip->i_df.if_u1.if_data; 382 /* 383 * Round i_bytes up to a word boundary. 384 * The underlying memory is guaranteed to 385 * to be there by xfs_idata_realloc(). 386 */ 387 data_bytes = roundup(ip->i_df.if_bytes, 4); 388 ASSERT((ip->i_df.if_real_bytes == 0) || 389 (ip->i_df.if_real_bytes == data_bytes)); 390 vecp->i_len = (int)data_bytes; 391 vecp->i_type = XLOG_REG_TYPE_ILOCAL; 392 vecp++; 393 nvecs++; 394 iip->ili_format.ilf_dsize = (unsigned)data_bytes; 395 } 396 break; 397 398 case XFS_DINODE_FMT_DEV: 399 ASSERT(!(iip->ili_format.ilf_fields & 400 (XFS_ILOG_DBROOT | XFS_ILOG_DEXT | 401 XFS_ILOG_DDATA | XFS_ILOG_UUID))); 402 if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) { 403 iip->ili_format.ilf_u.ilfu_rdev = 404 ip->i_df.if_u2.if_rdev; 405 } 406 break; 407 408 case XFS_DINODE_FMT_UUID: 409 ASSERT(!(iip->ili_format.ilf_fields & 410 (XFS_ILOG_DBROOT | XFS_ILOG_DEXT | 411 XFS_ILOG_DDATA | XFS_ILOG_DEV))); 412 if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) { 413 iip->ili_format.ilf_u.ilfu_uuid = 414 ip->i_df.if_u2.if_uuid; 415 } 416 break; 417 418 default: 419 ASSERT(0); 420 break; 421 } 422 423 /* 424 * If there are no attributes associated with the file, 425 * then we're done. 426 * Assert that no attribute-related log flags are set. 427 */ 428 if (!XFS_IFORK_Q(ip)) { 429 ASSERT(nvecs == lip->li_desc->lid_size); 430 iip->ili_format.ilf_size = nvecs; 431 ASSERT(!(iip->ili_format.ilf_fields & 432 (XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT))); 433 return; 434 } 435 436 switch (ip->i_d.di_aformat) { 437 case XFS_DINODE_FMT_EXTENTS: 438 ASSERT(!(iip->ili_format.ilf_fields & 439 (XFS_ILOG_ADATA | XFS_ILOG_ABROOT))); 440 if (iip->ili_format.ilf_fields & XFS_ILOG_AEXT) { 441#ifdef DEBUG 442 int nrecs = ip->i_afp->if_bytes / 443 (uint)sizeof(xfs_bmbt_rec_t); 444 ASSERT(nrecs > 0); 445 ASSERT(nrecs == ip->i_d.di_anextents); 446 ASSERT(ip->i_afp->if_bytes > 0); 447 ASSERT(ip->i_afp->if_u1.if_extents != NULL); 448 ASSERT(ip->i_d.di_anextents > 0); 449#endif 450#ifdef XFS_NATIVE_HOST 451 /* 452 * There are not delayed allocation extents 453 * for attributes, so just point at the array. 454 */ 455 vecp->i_addr = ip->i_afp->if_u1.if_extents; 456 vecp->i_len = ip->i_afp->if_bytes; 457#else 458 ASSERT(iip->ili_aextents_buf == NULL); 459 /* 460 * Need to endian flip before logging 461 */ 462 ext_buffer = kmem_alloc(ip->i_afp->if_bytes, 463 KM_SLEEP); 464 iip->ili_aextents_buf = ext_buffer; 465 vecp->i_addr = ext_buffer; 466 vecp->i_len = xfs_iextents_copy(ip, ext_buffer, 467 XFS_ATTR_FORK); 468#endif 469 vecp->i_type = XLOG_REG_TYPE_IATTR_EXT; 470 iip->ili_format.ilf_asize = vecp->i_len; 471 vecp++; 472 nvecs++; 473 } 474 break; 475 476 case XFS_DINODE_FMT_BTREE: 477 ASSERT(!(iip->ili_format.ilf_fields & 478 (XFS_ILOG_ADATA | XFS_ILOG_AEXT))); 479 if (iip->ili_format.ilf_fields & XFS_ILOG_ABROOT) { 480 ASSERT(ip->i_afp->if_broot_bytes > 0); 481 ASSERT(ip->i_afp->if_broot != NULL); 482 vecp->i_addr = ip->i_afp->if_broot; 483 vecp->i_len = ip->i_afp->if_broot_bytes; 484 vecp->i_type = XLOG_REG_TYPE_IATTR_BROOT; 485 vecp++; 486 nvecs++; 487 iip->ili_format.ilf_asize = ip->i_afp->if_broot_bytes; 488 } 489 break; 490 491 case XFS_DINODE_FMT_LOCAL: 492 ASSERT(!(iip->ili_format.ilf_fields & 493 (XFS_ILOG_ABROOT | XFS_ILOG_AEXT))); 494 if (iip->ili_format.ilf_fields & XFS_ILOG_ADATA) { 495 ASSERT(ip->i_afp->if_bytes > 0); 496 ASSERT(ip->i_afp->if_u1.if_data != NULL); 497 498 vecp->i_addr = ip->i_afp->if_u1.if_data; 499 /* 500 * Round i_bytes up to a word boundary. 501 * The underlying memory is guaranteed to 502 * to be there by xfs_idata_realloc(). 503 */ 504 data_bytes = roundup(ip->i_afp->if_bytes, 4); 505 ASSERT((ip->i_afp->if_real_bytes == 0) || 506 (ip->i_afp->if_real_bytes == data_bytes)); 507 vecp->i_len = (int)data_bytes; 508 vecp->i_type = XLOG_REG_TYPE_IATTR_LOCAL; 509 vecp++; 510 nvecs++; 511 iip->ili_format.ilf_asize = (unsigned)data_bytes; 512 } 513 break; 514 515 default: 516 ASSERT(0); 517 break; 518 } 519 520 ASSERT(nvecs == lip->li_desc->lid_size); 521 iip->ili_format.ilf_size = nvecs; 522} 523 524 525/* 526 * This is called to pin the inode associated with the inode log 527 * item in memory so it cannot be written out. 528 */ 529STATIC void 530xfs_inode_item_pin( 531 struct xfs_log_item *lip) 532{ 533 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode; 534 535 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 536 537 trace_xfs_inode_pin(ip, _RET_IP_); 538 atomic_inc(&ip->i_pincount); 539} 540 541 542/* 543 * This is called to unpin the inode associated with the inode log 544 * item which was previously pinned with a call to xfs_inode_item_pin(). 545 * 546 * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0. 547 */ 548STATIC void 549xfs_inode_item_unpin( 550 struct xfs_log_item *lip, 551 int remove) 552{ 553 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode; 554 555 trace_xfs_inode_unpin(ip, _RET_IP_); 556 ASSERT(atomic_read(&ip->i_pincount) > 0); 557 if (atomic_dec_and_test(&ip->i_pincount)) 558 wake_up(&ip->i_ipin_wait); 559} 560 561/* 562 * This is called to attempt to lock the inode associated with this 563 * inode log item, in preparation for the push routine which does the actual 564 * iflush. Don't sleep on the inode lock or the flush lock. 565 * 566 * If the flush lock is already held, indicating that the inode has 567 * been or is in the process of being flushed, then (ideally) we'd like to 568 * see if the inode's buffer is still incore, and if so give it a nudge. 569 * We delay doing so until the pushbuf routine, though, to avoid holding 570 * the AIL lock across a call to the blackhole which is the buffer cache. 571 * Also we don't want to sleep in any device strategy routines, which can happen 572 * if we do the subsequent bawrite in here. 573 */ 574STATIC uint 575xfs_inode_item_trylock( 576 struct xfs_log_item *lip) 577{ 578 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 579 struct xfs_inode *ip = iip->ili_inode; 580 581 if (xfs_ipincount(ip) > 0) 582 return XFS_ITEM_PINNED; 583 584 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) 585 return XFS_ITEM_LOCKED; 586 587 if (!xfs_iflock_nowait(ip)) { 588 /* 589 * inode has already been flushed to the backing buffer, 590 * leave it locked in shared mode, pushbuf routine will 591 * unlock it. 592 */ 593 return XFS_ITEM_PUSHBUF; 594 } 595 596 /* Stale items should force out the iclog */ 597 if (ip->i_flags & XFS_ISTALE) { 598 xfs_ifunlock(ip); 599 /* 600 * we hold the AIL lock - notify the unlock routine of this 601 * so it doesn't try to get the lock again. 602 */ 603 xfs_iunlock(ip, XFS_ILOCK_SHARED|XFS_IUNLOCK_NONOTIFY); 604 return XFS_ITEM_PINNED; 605 } 606 607#ifdef DEBUG 608 if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) { 609 ASSERT(iip->ili_format.ilf_fields != 0); 610 ASSERT(iip->ili_logged == 0); 611 ASSERT(lip->li_flags & XFS_LI_IN_AIL); 612 } 613#endif 614 return XFS_ITEM_SUCCESS; 615} 616 617/* 618 * Unlock the inode associated with the inode log item. 619 * Clear the fields of the inode and inode log item that 620 * are specific to the current transaction. If the 621 * hold flags is set, do not unlock the inode. 622 */ 623STATIC void 624xfs_inode_item_unlock( 625 struct xfs_log_item *lip) 626{ 627 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 628 struct xfs_inode *ip = iip->ili_inode; 629 unsigned short lock_flags; 630 631 ASSERT(iip->ili_inode->i_itemp != NULL); 632 ASSERT(xfs_isilocked(iip->ili_inode, XFS_ILOCK_EXCL)); 633 634 /* 635 * Clear the transaction pointer in the inode. 636 */ 637 ip->i_transp = NULL; 638 639 /* 640 * If the inode needed a separate buffer with which to log 641 * its extents, then free it now. 642 */ 643 if (iip->ili_extents_buf != NULL) { 644 ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS); 645 ASSERT(ip->i_d.di_nextents > 0); 646 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_DEXT); 647 ASSERT(ip->i_df.if_bytes > 0); 648 kmem_free(iip->ili_extents_buf); 649 iip->ili_extents_buf = NULL; 650 } 651 if (iip->ili_aextents_buf != NULL) { 652 ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS); 653 ASSERT(ip->i_d.di_anextents > 0); 654 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_AEXT); 655 ASSERT(ip->i_afp->if_bytes > 0); 656 kmem_free(iip->ili_aextents_buf); 657 iip->ili_aextents_buf = NULL; 658 } 659 660 lock_flags = iip->ili_lock_flags; 661 iip->ili_lock_flags = 0; 662 if (lock_flags) { 663 xfs_iunlock(iip->ili_inode, lock_flags); 664 IRELE(iip->ili_inode); 665 } 666} 667 668/* 669 * This is called to find out where the oldest active copy of the 670 * inode log item in the on disk log resides now that the last log 671 * write of it completed at the given lsn. Since we always re-log 672 * all dirty data in an inode, the latest copy in the on disk log 673 * is the only one that matters. Therefore, simply return the 674 * given lsn. 675 */ 676STATIC xfs_lsn_t 677xfs_inode_item_committed( 678 struct xfs_log_item *lip, 679 xfs_lsn_t lsn) 680{ 681 return lsn; 682} 683 684/* 685 * This gets called by xfs_trans_push_ail(), when IOP_TRYLOCK 686 * failed to get the inode flush lock but did get the inode locked SHARED. 687 * Here we're trying to see if the inode buffer is incore, and if so whether it's 688 * marked delayed write. If that's the case, we'll promote it and that will 689 * allow the caller to write the buffer by triggering the xfsbufd to run. 690 */ 691STATIC void 692xfs_inode_item_pushbuf( 693 struct xfs_log_item *lip) 694{ 695 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 696 struct xfs_inode *ip = iip->ili_inode; 697 struct xfs_buf *bp; 698 699 ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED)); 700 701 /* 702 * If a flush is not in progress anymore, chances are that the 703 * inode was taken off the AIL. So, just get out. 704 */ 705 if (completion_done(&ip->i_flush) || 706 !(lip->li_flags & XFS_LI_IN_AIL)) { 707 xfs_iunlock(ip, XFS_ILOCK_SHARED); 708 return; 709 } 710 711 bp = xfs_incore(ip->i_mount->m_ddev_targp, iip->ili_format.ilf_blkno, 712 iip->ili_format.ilf_len, XBF_TRYLOCK); 713 714 xfs_iunlock(ip, XFS_ILOCK_SHARED); 715 if (!bp) 716 return; 717 if (XFS_BUF_ISDELAYWRITE(bp)) 718 xfs_buf_delwri_promote(bp); 719 xfs_buf_relse(bp); 720} 721 722/* 723 * This is called to asynchronously write the inode associated with this 724 * inode log item out to disk. The inode will already have been locked by 725 * a successful call to xfs_inode_item_trylock(). 726 */ 727STATIC void 728xfs_inode_item_push( 729 struct xfs_log_item *lip) 730{ 731 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 732 struct xfs_inode *ip = iip->ili_inode; 733 734 ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED)); 735 ASSERT(!completion_done(&ip->i_flush)); 736 737 /* 738 * Since we were able to lock the inode's flush lock and 739 * we found it on the AIL, the inode must be dirty. This 740 * is because the inode is removed from the AIL while still 741 * holding the flush lock in xfs_iflush_done(). Thus, if 742 * we found it in the AIL and were able to obtain the flush 743 * lock without sleeping, then there must not have been 744 * anyone in the process of flushing the inode. 745 */ 746 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || 747 iip->ili_format.ilf_fields != 0); 748 749 /* 750 * Push the inode to it's backing buffer. This will not remove the 751 * inode from the AIL - a further push will be required to trigger a 752 * buffer push. However, this allows all the dirty inodes to be pushed 753 * to the buffer before it is pushed to disk. THe buffer IO completion 754 * will pull th einode from the AIL, mark it clean and unlock the flush 755 * lock. 756 */ 757 (void) xfs_iflush(ip, 0); 758 xfs_iunlock(ip, XFS_ILOCK_SHARED); 759} 760 761STATIC void 762xfs_inode_item_committing( 763 struct xfs_log_item *lip, 764 xfs_lsn_t lsn) 765{ 766 INODE_ITEM(lip)->ili_last_lsn = lsn; 767} 768 769/* 770 * This is the ops vector shared by all buf log items. 771 */ 772static struct xfs_item_ops xfs_inode_item_ops = { 773 .iop_size = xfs_inode_item_size, 774 .iop_format = xfs_inode_item_format, 775 .iop_pin = xfs_inode_item_pin, 776 .iop_unpin = xfs_inode_item_unpin, 777 .iop_trylock = xfs_inode_item_trylock, 778 .iop_unlock = xfs_inode_item_unlock, 779 .iop_committed = xfs_inode_item_committed, 780 .iop_push = xfs_inode_item_push, 781 .iop_pushbuf = xfs_inode_item_pushbuf, 782 .iop_committing = xfs_inode_item_committing 783}; 784 785 786/* 787 * Initialize the inode log item for a newly allocated (in-core) inode. 788 */ 789void 790xfs_inode_item_init( 791 struct xfs_inode *ip, 792 struct xfs_mount *mp) 793{ 794 struct xfs_inode_log_item *iip; 795 796 ASSERT(ip->i_itemp == NULL); 797 iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP); 798 799 iip->ili_inode = ip; 800 xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE, 801 &xfs_inode_item_ops); 802 iip->ili_format.ilf_type = XFS_LI_INODE; 803 iip->ili_format.ilf_ino = ip->i_ino; 804 iip->ili_format.ilf_blkno = ip->i_imap.im_blkno; 805 iip->ili_format.ilf_len = ip->i_imap.im_len; 806 iip->ili_format.ilf_boffset = ip->i_imap.im_boffset; 807} 808 809/* 810 * Free the inode log item and any memory hanging off of it. 811 */ 812void 813xfs_inode_item_destroy( 814 xfs_inode_t *ip) 815{ 816#ifdef XFS_TRANS_DEBUG 817 if (ip->i_itemp->ili_root_size != 0) { 818 kmem_free(ip->i_itemp->ili_orig_root); 819 } 820#endif 821 kmem_zone_free(xfs_ili_zone, ip->i_itemp); 822} 823 824 825/* 826 * This is the inode flushing I/O completion routine. It is called 827 * from interrupt level when the buffer containing the inode is 828 * flushed to disk. It is responsible for removing the inode item 829 * from the AIL if it has not been re-logged, and unlocking the inode's 830 * flush lock. 831 */ 832void 833xfs_iflush_done( 834 struct xfs_buf *bp, 835 struct xfs_log_item *lip) 836{ 837 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 838 xfs_inode_t *ip = iip->ili_inode; 839 struct xfs_ail *ailp = lip->li_ailp; 840 841 /* 842 * We only want to pull the item from the AIL if it is 843 * actually there and its location in the log has not 844 * changed since we started the flush. Thus, we only bother 845 * if the ili_logged flag is set and the inode's lsn has not 846 * changed. First we check the lsn outside 847 * the lock since it's cheaper, and then we recheck while 848 * holding the lock before removing the inode from the AIL. 849 */ 850 if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn) { 851 spin_lock(&ailp->xa_lock); 852 if (lip->li_lsn == iip->ili_flush_lsn) { 853 /* xfs_trans_ail_delete() drops the AIL lock. */ 854 xfs_trans_ail_delete(ailp, lip); 855 } else { 856 spin_unlock(&ailp->xa_lock); 857 } 858 } 859 860 iip->ili_logged = 0; 861 862 /* 863 * Clear the ili_last_fields bits now that we know that the 864 * data corresponding to them is safely on disk. 865 */ 866 iip->ili_last_fields = 0; 867 868 /* 869 * Release the inode's flush lock since we're done with it. 870 */ 871 xfs_ifunlock(ip); 872} 873 874/* 875 * This is the inode flushing abort routine. It is called 876 * from xfs_iflush when the filesystem is shutting down to clean 877 * up the inode state. 878 * It is responsible for removing the inode item 879 * from the AIL if it has not been re-logged, and unlocking the inode's 880 * flush lock. 881 */ 882void 883xfs_iflush_abort( 884 xfs_inode_t *ip) 885{ 886 xfs_inode_log_item_t *iip = ip->i_itemp; 887 888 iip = ip->i_itemp; 889 if (iip) { 890 struct xfs_ail *ailp = iip->ili_item.li_ailp; 891 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) { 892 spin_lock(&ailp->xa_lock); 893 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) { 894 /* xfs_trans_ail_delete() drops the AIL lock. */ 895 xfs_trans_ail_delete(ailp, (xfs_log_item_t *)iip); 896 } else 897 spin_unlock(&ailp->xa_lock); 898 } 899 iip->ili_logged = 0; 900 /* 901 * Clear the ili_last_fields bits now that we know that the 902 * data corresponding to them is safely on disk. 903 */ 904 iip->ili_last_fields = 0; 905 /* 906 * Clear the inode logging fields so no more flushes are 907 * attempted. 908 */ 909 iip->ili_format.ilf_fields = 0; 910 } 911 /* 912 * Release the inode's flush lock since we're done with it. 913 */ 914 xfs_ifunlock(ip); 915} 916 917void 918xfs_istale_done( 919 struct xfs_buf *bp, 920 struct xfs_log_item *lip) 921{ 922 xfs_iflush_abort(INODE_ITEM(lip)->ili_inode); 923} 924 925/* 926 * convert an xfs_inode_log_format struct from either 32 or 64 bit versions 927 * (which can have different field alignments) to the native version 928 */ 929int 930xfs_inode_item_format_convert( 931 xfs_log_iovec_t *buf, 932 xfs_inode_log_format_t *in_f) 933{ 934 if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) { 935 xfs_inode_log_format_32_t *in_f32 = buf->i_addr; 936 937 in_f->ilf_type = in_f32->ilf_type; 938 in_f->ilf_size = in_f32->ilf_size; 939 in_f->ilf_fields = in_f32->ilf_fields; 940 in_f->ilf_asize = in_f32->ilf_asize; 941 in_f->ilf_dsize = in_f32->ilf_dsize; 942 in_f->ilf_ino = in_f32->ilf_ino; 943 /* copy biggest field of ilf_u */ 944 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits, 945 in_f32->ilf_u.ilfu_uuid.__u_bits, 946 sizeof(uuid_t)); 947 in_f->ilf_blkno = in_f32->ilf_blkno; 948 in_f->ilf_len = in_f32->ilf_len; 949 in_f->ilf_boffset = in_f32->ilf_boffset; 950 return 0; 951 } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){ 952 xfs_inode_log_format_64_t *in_f64 = buf->i_addr; 953 954 in_f->ilf_type = in_f64->ilf_type; 955 in_f->ilf_size = in_f64->ilf_size; 956 in_f->ilf_fields = in_f64->ilf_fields; 957 in_f->ilf_asize = in_f64->ilf_asize; 958 in_f->ilf_dsize = in_f64->ilf_dsize; 959 in_f->ilf_ino = in_f64->ilf_ino; 960 /* copy biggest field of ilf_u */ 961 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits, 962 in_f64->ilf_u.ilfu_uuid.__u_bits, 963 sizeof(uuid_t)); 964 in_f->ilf_blkno = in_f64->ilf_blkno; 965 in_f->ilf_len = in_f64->ilf_len; 966 in_f->ilf_boffset = in_f64->ilf_boffset; 967 return 0; 968 } 969 return EFSCORRUPTED; 970} 971