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 37 kmem_zone_t *xfs_ili_zone; /* inode log item zone */ 38 39 static 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 */ 52 STATIC uint 53 xfs_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 */ 207 STATIC void 208 xfs_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 */ 529 STATIC void 530 xfs_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 */ 548 STATIC void 549 xfs_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 */ 574 STATIC uint 575 xfs_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 */ 623 STATIC void 624 xfs_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 */ 676 STATIC xfs_lsn_t 677 xfs_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 */ 691 STATIC void 692 xfs_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 */ 727 STATIC void 728 xfs_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 761 /* 762 * XXX rcc - this one really has to do something. Probably needs 763 * to stamp in a new field in the incore inode. 764 */ 765 STATIC void 766 xfs_inode_item_committing( 767 struct xfs_log_item *lip, 768 xfs_lsn_t lsn) 769 { 770 INODE_ITEM(lip)->ili_last_lsn = lsn; 771 } 772 773 /* 774 * This is the ops vector shared by all buf log items. 775 */ 776 static struct xfs_item_ops xfs_inode_item_ops = { 777 .iop_size = xfs_inode_item_size, 778 .iop_format = xfs_inode_item_format, 779 .iop_pin = xfs_inode_item_pin, 780 .iop_unpin = xfs_inode_item_unpin, 781 .iop_trylock = xfs_inode_item_trylock, 782 .iop_unlock = xfs_inode_item_unlock, 783 .iop_committed = xfs_inode_item_committed, 784 .iop_push = xfs_inode_item_push, 785 .iop_pushbuf = xfs_inode_item_pushbuf, 786 .iop_committing = xfs_inode_item_committing 787 }; 788 789 790 /* 791 * Initialize the inode log item for a newly allocated (in-core) inode. 792 */ 793 void 794 xfs_inode_item_init( 795 struct xfs_inode *ip, 796 struct xfs_mount *mp) 797 { 798 struct xfs_inode_log_item *iip; 799 800 ASSERT(ip->i_itemp == NULL); 801 iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP); 802 803 iip->ili_inode = ip; 804 xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE, 805 &xfs_inode_item_ops); 806 iip->ili_format.ilf_type = XFS_LI_INODE; 807 iip->ili_format.ilf_ino = ip->i_ino; 808 iip->ili_format.ilf_blkno = ip->i_imap.im_blkno; 809 iip->ili_format.ilf_len = ip->i_imap.im_len; 810 iip->ili_format.ilf_boffset = ip->i_imap.im_boffset; 811 } 812 813 /* 814 * Free the inode log item and any memory hanging off of it. 815 */ 816 void 817 xfs_inode_item_destroy( 818 xfs_inode_t *ip) 819 { 820 #ifdef XFS_TRANS_DEBUG 821 if (ip->i_itemp->ili_root_size != 0) { 822 kmem_free(ip->i_itemp->ili_orig_root); 823 } 824 #endif 825 kmem_zone_free(xfs_ili_zone, ip->i_itemp); 826 } 827 828 829 /* 830 * This is the inode flushing I/O completion routine. It is called 831 * from interrupt level when the buffer containing the inode is 832 * flushed to disk. It is responsible for removing the inode item 833 * from the AIL if it has not been re-logged, and unlocking the inode's 834 * flush lock. 835 */ 836 void 837 xfs_iflush_done( 838 struct xfs_buf *bp, 839 struct xfs_log_item *lip) 840 { 841 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 842 xfs_inode_t *ip = iip->ili_inode; 843 struct xfs_ail *ailp = lip->li_ailp; 844 845 /* 846 * We only want to pull the item from the AIL if it is 847 * actually there and its location in the log has not 848 * changed since we started the flush. Thus, we only bother 849 * if the ili_logged flag is set and the inode's lsn has not 850 * changed. First we check the lsn outside 851 * the lock since it's cheaper, and then we recheck while 852 * holding the lock before removing the inode from the AIL. 853 */ 854 if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn) { 855 spin_lock(&ailp->xa_lock); 856 if (lip->li_lsn == iip->ili_flush_lsn) { 857 /* xfs_trans_ail_delete() drops the AIL lock. */ 858 xfs_trans_ail_delete(ailp, lip); 859 } else { 860 spin_unlock(&ailp->xa_lock); 861 } 862 } 863 864 iip->ili_logged = 0; 865 866 /* 867 * Clear the ili_last_fields bits now that we know that the 868 * data corresponding to them is safely on disk. 869 */ 870 iip->ili_last_fields = 0; 871 872 /* 873 * Release the inode's flush lock since we're done with it. 874 */ 875 xfs_ifunlock(ip); 876 } 877 878 /* 879 * This is the inode flushing abort routine. It is called 880 * from xfs_iflush when the filesystem is shutting down to clean 881 * up the inode state. 882 * It is responsible for removing the inode item 883 * from the AIL if it has not been re-logged, and unlocking the inode's 884 * flush lock. 885 */ 886 void 887 xfs_iflush_abort( 888 xfs_inode_t *ip) 889 { 890 xfs_inode_log_item_t *iip = ip->i_itemp; 891 892 iip = ip->i_itemp; 893 if (iip) { 894 struct xfs_ail *ailp = iip->ili_item.li_ailp; 895 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) { 896 spin_lock(&ailp->xa_lock); 897 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) { 898 /* xfs_trans_ail_delete() drops the AIL lock. */ 899 xfs_trans_ail_delete(ailp, (xfs_log_item_t *)iip); 900 } else 901 spin_unlock(&ailp->xa_lock); 902 } 903 iip->ili_logged = 0; 904 /* 905 * Clear the ili_last_fields bits now that we know that the 906 * data corresponding to them is safely on disk. 907 */ 908 iip->ili_last_fields = 0; 909 /* 910 * Clear the inode logging fields so no more flushes are 911 * attempted. 912 */ 913 iip->ili_format.ilf_fields = 0; 914 } 915 /* 916 * Release the inode's flush lock since we're done with it. 917 */ 918 xfs_ifunlock(ip); 919 } 920 921 void 922 xfs_istale_done( 923 struct xfs_buf *bp, 924 struct xfs_log_item *lip) 925 { 926 xfs_iflush_abort(INODE_ITEM(lip)->ili_inode); 927 } 928 929 /* 930 * convert an xfs_inode_log_format struct from either 32 or 64 bit versions 931 * (which can have different field alignments) to the native version 932 */ 933 int 934 xfs_inode_item_format_convert( 935 xfs_log_iovec_t *buf, 936 xfs_inode_log_format_t *in_f) 937 { 938 if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) { 939 xfs_inode_log_format_32_t *in_f32 = buf->i_addr; 940 941 in_f->ilf_type = in_f32->ilf_type; 942 in_f->ilf_size = in_f32->ilf_size; 943 in_f->ilf_fields = in_f32->ilf_fields; 944 in_f->ilf_asize = in_f32->ilf_asize; 945 in_f->ilf_dsize = in_f32->ilf_dsize; 946 in_f->ilf_ino = in_f32->ilf_ino; 947 /* copy biggest field of ilf_u */ 948 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits, 949 in_f32->ilf_u.ilfu_uuid.__u_bits, 950 sizeof(uuid_t)); 951 in_f->ilf_blkno = in_f32->ilf_blkno; 952 in_f->ilf_len = in_f32->ilf_len; 953 in_f->ilf_boffset = in_f32->ilf_boffset; 954 return 0; 955 } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){ 956 xfs_inode_log_format_64_t *in_f64 = buf->i_addr; 957 958 in_f->ilf_type = in_f64->ilf_type; 959 in_f->ilf_size = in_f64->ilf_size; 960 in_f->ilf_fields = in_f64->ilf_fields; 961 in_f->ilf_asize = in_f64->ilf_asize; 962 in_f->ilf_dsize = in_f64->ilf_dsize; 963 in_f->ilf_ino = in_f64->ilf_ino; 964 /* copy biggest field of ilf_u */ 965 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits, 966 in_f64->ilf_u.ilfu_uuid.__u_bits, 967 sizeof(uuid_t)); 968 in_f->ilf_blkno = in_f64->ilf_blkno; 969 in_f->ilf_len = in_f64->ilf_len; 970 in_f->ilf_boffset = in_f64->ilf_boffset; 971 return 0; 972 } 973 return EFSCORRUPTED; 974 } 975