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 * Clear i_update_core if the timestamps (or any other 227 * non-transactional modification) need flushing/logging 228 * and we're about to log them with the rest of the core. 229 * 230 * This is the same logic as xfs_iflush() but this code can't 231 * run at the same time as xfs_iflush because we're in commit 232 * processing here and so we have the inode lock held in 233 * exclusive mode. Although it doesn't really matter 234 * for the timestamps if both routines were to grab the 235 * timestamps or not. That would be ok. 236 * 237 * We clear i_update_core before copying out the data. 238 * This is for coordination with our timestamp updates 239 * that don't hold the inode lock. They will always 240 * update the timestamps BEFORE setting i_update_core, 241 * so if we clear i_update_core after they set it we 242 * are guaranteed to see their updates to the timestamps 243 * either here. Likewise, if they set it after we clear it 244 * here, we'll see it either on the next commit of this 245 * inode or the next time the inode gets flushed via 246 * xfs_iflush(). This depends on strongly ordered memory 247 * semantics, but we have that. We use the SYNCHRONIZE 248 * macro to make sure that the compiler does not reorder 249 * the i_update_core access below the data copy below. 250 */ 251 if (ip->i_update_core) { 252 ip->i_update_core = 0; 253 SYNCHRONIZE(); 254 } 255 256 /* 257 * Make sure to get the latest timestamps from the Linux inode. 258 */ 259 xfs_synchronize_times(ip); 260 261 vecp->i_addr = &ip->i_d; 262 vecp->i_len = sizeof(struct xfs_icdinode); 263 vecp->i_type = XLOG_REG_TYPE_ICORE; 264 vecp++; 265 nvecs++; 266 iip->ili_format.ilf_fields |= XFS_ILOG_CORE; 267 268 /* 269 * If this is really an old format inode, then we need to 270 * log it as such. This means that we have to copy the link 271 * count from the new field to the old. We don't have to worry 272 * about the new fields, because nothing trusts them as long as 273 * the old inode version number is there. If the superblock already 274 * has a new version number, then we don't bother converting back. 275 */ 276 mp = ip->i_mount; 277 ASSERT(ip->i_d.di_version == 1 || xfs_sb_version_hasnlink(&mp->m_sb)); 278 if (ip->i_d.di_version == 1) { 279 if (!xfs_sb_version_hasnlink(&mp->m_sb)) { 280 /* 281 * Convert it back. 282 */ 283 ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1); 284 ip->i_d.di_onlink = ip->i_d.di_nlink; 285 } else { 286 /* 287 * The superblock version has already been bumped, 288 * so just make the conversion to the new inode 289 * format permanent. 290 */ 291 ip->i_d.di_version = 2; 292 ip->i_d.di_onlink = 0; 293 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad)); 294 } 295 } 296 297 switch (ip->i_d.di_format) { 298 case XFS_DINODE_FMT_EXTENTS: 299 ASSERT(!(iip->ili_format.ilf_fields & 300 (XFS_ILOG_DDATA | XFS_ILOG_DBROOT | 301 XFS_ILOG_DEV | XFS_ILOG_UUID))); 302 if (iip->ili_format.ilf_fields & XFS_ILOG_DEXT) { 303 ASSERT(ip->i_df.if_bytes > 0); 304 ASSERT(ip->i_df.if_u1.if_extents != NULL); 305 ASSERT(ip->i_d.di_nextents > 0); 306 ASSERT(iip->ili_extents_buf == NULL); 307 ASSERT((ip->i_df.if_bytes / 308 (uint)sizeof(xfs_bmbt_rec_t)) > 0); 309 #ifdef XFS_NATIVE_HOST 310 if (ip->i_d.di_nextents == ip->i_df.if_bytes / 311 (uint)sizeof(xfs_bmbt_rec_t)) { 312 /* 313 * There are no delayed allocation 314 * extents, so just point to the 315 * real extents array. 316 */ 317 vecp->i_addr = ip->i_df.if_u1.if_extents; 318 vecp->i_len = ip->i_df.if_bytes; 319 vecp->i_type = XLOG_REG_TYPE_IEXT; 320 } else 321 #endif 322 { 323 /* 324 * There are delayed allocation extents 325 * in the inode, or we need to convert 326 * the extents to on disk format. 327 * Use xfs_iextents_copy() 328 * to copy only the real extents into 329 * a separate buffer. We'll free the 330 * buffer in the unlock routine. 331 */ 332 ext_buffer = kmem_alloc(ip->i_df.if_bytes, 333 KM_SLEEP); 334 iip->ili_extents_buf = ext_buffer; 335 vecp->i_addr = ext_buffer; 336 vecp->i_len = xfs_iextents_copy(ip, ext_buffer, 337 XFS_DATA_FORK); 338 vecp->i_type = XLOG_REG_TYPE_IEXT; 339 } 340 ASSERT(vecp->i_len <= ip->i_df.if_bytes); 341 iip->ili_format.ilf_dsize = vecp->i_len; 342 vecp++; 343 nvecs++; 344 } 345 break; 346 347 case XFS_DINODE_FMT_BTREE: 348 ASSERT(!(iip->ili_format.ilf_fields & 349 (XFS_ILOG_DDATA | XFS_ILOG_DEXT | 350 XFS_ILOG_DEV | XFS_ILOG_UUID))); 351 if (iip->ili_format.ilf_fields & XFS_ILOG_DBROOT) { 352 ASSERT(ip->i_df.if_broot_bytes > 0); 353 ASSERT(ip->i_df.if_broot != NULL); 354 vecp->i_addr = ip->i_df.if_broot; 355 vecp->i_len = ip->i_df.if_broot_bytes; 356 vecp->i_type = XLOG_REG_TYPE_IBROOT; 357 vecp++; 358 nvecs++; 359 iip->ili_format.ilf_dsize = ip->i_df.if_broot_bytes; 360 } 361 break; 362 363 case XFS_DINODE_FMT_LOCAL: 364 ASSERT(!(iip->ili_format.ilf_fields & 365 (XFS_ILOG_DBROOT | XFS_ILOG_DEXT | 366 XFS_ILOG_DEV | XFS_ILOG_UUID))); 367 if (iip->ili_format.ilf_fields & XFS_ILOG_DDATA) { 368 ASSERT(ip->i_df.if_bytes > 0); 369 ASSERT(ip->i_df.if_u1.if_data != NULL); 370 ASSERT(ip->i_d.di_size > 0); 371 372 vecp->i_addr = ip->i_df.if_u1.if_data; 373 /* 374 * Round i_bytes up to a word boundary. 375 * The underlying memory is guaranteed to 376 * to be there by xfs_idata_realloc(). 377 */ 378 data_bytes = roundup(ip->i_df.if_bytes, 4); 379 ASSERT((ip->i_df.if_real_bytes == 0) || 380 (ip->i_df.if_real_bytes == data_bytes)); 381 vecp->i_len = (int)data_bytes; 382 vecp->i_type = XLOG_REG_TYPE_ILOCAL; 383 vecp++; 384 nvecs++; 385 iip->ili_format.ilf_dsize = (unsigned)data_bytes; 386 } 387 break; 388 389 case XFS_DINODE_FMT_DEV: 390 ASSERT(!(iip->ili_format.ilf_fields & 391 (XFS_ILOG_DBROOT | XFS_ILOG_DEXT | 392 XFS_ILOG_DDATA | XFS_ILOG_UUID))); 393 if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) { 394 iip->ili_format.ilf_u.ilfu_rdev = 395 ip->i_df.if_u2.if_rdev; 396 } 397 break; 398 399 case XFS_DINODE_FMT_UUID: 400 ASSERT(!(iip->ili_format.ilf_fields & 401 (XFS_ILOG_DBROOT | XFS_ILOG_DEXT | 402 XFS_ILOG_DDATA | XFS_ILOG_DEV))); 403 if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) { 404 iip->ili_format.ilf_u.ilfu_uuid = 405 ip->i_df.if_u2.if_uuid; 406 } 407 break; 408 409 default: 410 ASSERT(0); 411 break; 412 } 413 414 /* 415 * If there are no attributes associated with the file, 416 * then we're done. 417 * Assert that no attribute-related log flags are set. 418 */ 419 if (!XFS_IFORK_Q(ip)) { 420 ASSERT(nvecs == lip->li_desc->lid_size); 421 iip->ili_format.ilf_size = nvecs; 422 ASSERT(!(iip->ili_format.ilf_fields & 423 (XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT))); 424 return; 425 } 426 427 switch (ip->i_d.di_aformat) { 428 case XFS_DINODE_FMT_EXTENTS: 429 ASSERT(!(iip->ili_format.ilf_fields & 430 (XFS_ILOG_ADATA | XFS_ILOG_ABROOT))); 431 if (iip->ili_format.ilf_fields & XFS_ILOG_AEXT) { 432 #ifdef DEBUG 433 int nrecs = ip->i_afp->if_bytes / 434 (uint)sizeof(xfs_bmbt_rec_t); 435 ASSERT(nrecs > 0); 436 ASSERT(nrecs == ip->i_d.di_anextents); 437 ASSERT(ip->i_afp->if_bytes > 0); 438 ASSERT(ip->i_afp->if_u1.if_extents != NULL); 439 ASSERT(ip->i_d.di_anextents > 0); 440 #endif 441 #ifdef XFS_NATIVE_HOST 442 /* 443 * There are not delayed allocation extents 444 * for attributes, so just point at the array. 445 */ 446 vecp->i_addr = ip->i_afp->if_u1.if_extents; 447 vecp->i_len = ip->i_afp->if_bytes; 448 #else 449 ASSERT(iip->ili_aextents_buf == NULL); 450 /* 451 * Need to endian flip before logging 452 */ 453 ext_buffer = kmem_alloc(ip->i_afp->if_bytes, 454 KM_SLEEP); 455 iip->ili_aextents_buf = ext_buffer; 456 vecp->i_addr = ext_buffer; 457 vecp->i_len = xfs_iextents_copy(ip, ext_buffer, 458 XFS_ATTR_FORK); 459 #endif 460 vecp->i_type = XLOG_REG_TYPE_IATTR_EXT; 461 iip->ili_format.ilf_asize = vecp->i_len; 462 vecp++; 463 nvecs++; 464 } 465 break; 466 467 case XFS_DINODE_FMT_BTREE: 468 ASSERT(!(iip->ili_format.ilf_fields & 469 (XFS_ILOG_ADATA | XFS_ILOG_AEXT))); 470 if (iip->ili_format.ilf_fields & XFS_ILOG_ABROOT) { 471 ASSERT(ip->i_afp->if_broot_bytes > 0); 472 ASSERT(ip->i_afp->if_broot != NULL); 473 vecp->i_addr = ip->i_afp->if_broot; 474 vecp->i_len = ip->i_afp->if_broot_bytes; 475 vecp->i_type = XLOG_REG_TYPE_IATTR_BROOT; 476 vecp++; 477 nvecs++; 478 iip->ili_format.ilf_asize = ip->i_afp->if_broot_bytes; 479 } 480 break; 481 482 case XFS_DINODE_FMT_LOCAL: 483 ASSERT(!(iip->ili_format.ilf_fields & 484 (XFS_ILOG_ABROOT | XFS_ILOG_AEXT))); 485 if (iip->ili_format.ilf_fields & XFS_ILOG_ADATA) { 486 ASSERT(ip->i_afp->if_bytes > 0); 487 ASSERT(ip->i_afp->if_u1.if_data != NULL); 488 489 vecp->i_addr = ip->i_afp->if_u1.if_data; 490 /* 491 * Round i_bytes up to a word boundary. 492 * The underlying memory is guaranteed to 493 * to be there by xfs_idata_realloc(). 494 */ 495 data_bytes = roundup(ip->i_afp->if_bytes, 4); 496 ASSERT((ip->i_afp->if_real_bytes == 0) || 497 (ip->i_afp->if_real_bytes == data_bytes)); 498 vecp->i_len = (int)data_bytes; 499 vecp->i_type = XLOG_REG_TYPE_IATTR_LOCAL; 500 vecp++; 501 nvecs++; 502 iip->ili_format.ilf_asize = (unsigned)data_bytes; 503 } 504 break; 505 506 default: 507 ASSERT(0); 508 break; 509 } 510 511 ASSERT(nvecs == lip->li_desc->lid_size); 512 iip->ili_format.ilf_size = nvecs; 513 } 514 515 516 /* 517 * This is called to pin the inode associated with the inode log 518 * item in memory so it cannot be written out. 519 */ 520 STATIC void 521 xfs_inode_item_pin( 522 struct xfs_log_item *lip) 523 { 524 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode; 525 526 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 527 528 trace_xfs_inode_pin(ip, _RET_IP_); 529 atomic_inc(&ip->i_pincount); 530 } 531 532 533 /* 534 * This is called to unpin the inode associated with the inode log 535 * item which was previously pinned with a call to xfs_inode_item_pin(). 536 * 537 * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0. 538 */ 539 STATIC void 540 xfs_inode_item_unpin( 541 struct xfs_log_item *lip, 542 int remove) 543 { 544 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode; 545 546 trace_xfs_inode_unpin(ip, _RET_IP_); 547 ASSERT(atomic_read(&ip->i_pincount) > 0); 548 if (atomic_dec_and_test(&ip->i_pincount)) 549 wake_up(&ip->i_ipin_wait); 550 } 551 552 /* 553 * This is called to attempt to lock the inode associated with this 554 * inode log item, in preparation for the push routine which does the actual 555 * iflush. Don't sleep on the inode lock or the flush lock. 556 * 557 * If the flush lock is already held, indicating that the inode has 558 * been or is in the process of being flushed, then (ideally) we'd like to 559 * see if the inode's buffer is still incore, and if so give it a nudge. 560 * We delay doing so until the pushbuf routine, though, to avoid holding 561 * the AIL lock across a call to the blackhole which is the buffer cache. 562 * Also we don't want to sleep in any device strategy routines, which can happen 563 * if we do the subsequent bawrite in here. 564 */ 565 STATIC uint 566 xfs_inode_item_trylock( 567 struct xfs_log_item *lip) 568 { 569 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 570 struct xfs_inode *ip = iip->ili_inode; 571 572 if (xfs_ipincount(ip) > 0) 573 return XFS_ITEM_PINNED; 574 575 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) 576 return XFS_ITEM_LOCKED; 577 578 if (!xfs_iflock_nowait(ip)) { 579 /* 580 * inode has already been flushed to the backing buffer, 581 * leave it locked in shared mode, pushbuf routine will 582 * unlock it. 583 */ 584 return XFS_ITEM_PUSHBUF; 585 } 586 587 /* Stale items should force out the iclog */ 588 if (ip->i_flags & XFS_ISTALE) { 589 xfs_ifunlock(ip); 590 /* 591 * we hold the AIL lock - notify the unlock routine of this 592 * so it doesn't try to get the lock again. 593 */ 594 xfs_iunlock(ip, XFS_ILOCK_SHARED|XFS_IUNLOCK_NONOTIFY); 595 return XFS_ITEM_PINNED; 596 } 597 598 #ifdef DEBUG 599 if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) { 600 ASSERT(iip->ili_format.ilf_fields != 0); 601 ASSERT(iip->ili_logged == 0); 602 ASSERT(lip->li_flags & XFS_LI_IN_AIL); 603 } 604 #endif 605 return XFS_ITEM_SUCCESS; 606 } 607 608 /* 609 * Unlock the inode associated with the inode log item. 610 * Clear the fields of the inode and inode log item that 611 * are specific to the current transaction. If the 612 * hold flags is set, do not unlock the inode. 613 */ 614 STATIC void 615 xfs_inode_item_unlock( 616 struct xfs_log_item *lip) 617 { 618 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 619 struct xfs_inode *ip = iip->ili_inode; 620 unsigned short lock_flags; 621 622 ASSERT(iip->ili_inode->i_itemp != NULL); 623 ASSERT(xfs_isilocked(iip->ili_inode, XFS_ILOCK_EXCL)); 624 625 /* 626 * Clear the transaction pointer in the inode. 627 */ 628 ip->i_transp = NULL; 629 630 /* 631 * If the inode needed a separate buffer with which to log 632 * its extents, then free it now. 633 */ 634 if (iip->ili_extents_buf != NULL) { 635 ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS); 636 ASSERT(ip->i_d.di_nextents > 0); 637 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_DEXT); 638 ASSERT(ip->i_df.if_bytes > 0); 639 kmem_free(iip->ili_extents_buf); 640 iip->ili_extents_buf = NULL; 641 } 642 if (iip->ili_aextents_buf != NULL) { 643 ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS); 644 ASSERT(ip->i_d.di_anextents > 0); 645 ASSERT(iip->ili_format.ilf_fields & XFS_ILOG_AEXT); 646 ASSERT(ip->i_afp->if_bytes > 0); 647 kmem_free(iip->ili_aextents_buf); 648 iip->ili_aextents_buf = NULL; 649 } 650 651 lock_flags = iip->ili_lock_flags; 652 iip->ili_lock_flags = 0; 653 if (lock_flags) { 654 xfs_iunlock(iip->ili_inode, lock_flags); 655 IRELE(iip->ili_inode); 656 } 657 } 658 659 /* 660 * This is called to find out where the oldest active copy of the 661 * inode log item in the on disk log resides now that the last log 662 * write of it completed at the given lsn. Since we always re-log 663 * all dirty data in an inode, the latest copy in the on disk log 664 * is the only one that matters. Therefore, simply return the 665 * given lsn. 666 */ 667 STATIC xfs_lsn_t 668 xfs_inode_item_committed( 669 struct xfs_log_item *lip, 670 xfs_lsn_t lsn) 671 { 672 return lsn; 673 } 674 675 /* 676 * This gets called by xfs_trans_push_ail(), when IOP_TRYLOCK 677 * failed to get the inode flush lock but did get the inode locked SHARED. 678 * Here we're trying to see if the inode buffer is incore, and if so whether it's 679 * marked delayed write. If that's the case, we'll promote it and that will 680 * allow the caller to write the buffer by triggering the xfsbufd to run. 681 */ 682 STATIC void 683 xfs_inode_item_pushbuf( 684 struct xfs_log_item *lip) 685 { 686 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 687 struct xfs_inode *ip = iip->ili_inode; 688 struct xfs_buf *bp; 689 690 ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED)); 691 692 /* 693 * If a flush is not in progress anymore, chances are that the 694 * inode was taken off the AIL. So, just get out. 695 */ 696 if (completion_done(&ip->i_flush) || 697 !(lip->li_flags & XFS_LI_IN_AIL)) { 698 xfs_iunlock(ip, XFS_ILOCK_SHARED); 699 return; 700 } 701 702 bp = xfs_incore(ip->i_mount->m_ddev_targp, iip->ili_format.ilf_blkno, 703 iip->ili_format.ilf_len, XBF_TRYLOCK); 704 705 xfs_iunlock(ip, XFS_ILOCK_SHARED); 706 if (!bp) 707 return; 708 if (XFS_BUF_ISDELAYWRITE(bp)) 709 xfs_buf_delwri_promote(bp); 710 xfs_buf_relse(bp); 711 } 712 713 /* 714 * This is called to asynchronously write the inode associated with this 715 * inode log item out to disk. The inode will already have been locked by 716 * a successful call to xfs_inode_item_trylock(). 717 */ 718 STATIC void 719 xfs_inode_item_push( 720 struct xfs_log_item *lip) 721 { 722 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 723 struct xfs_inode *ip = iip->ili_inode; 724 725 ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED)); 726 ASSERT(!completion_done(&ip->i_flush)); 727 728 /* 729 * Since we were able to lock the inode's flush lock and 730 * we found it on the AIL, the inode must be dirty. This 731 * is because the inode is removed from the AIL while still 732 * holding the flush lock in xfs_iflush_done(). Thus, if 733 * we found it in the AIL and were able to obtain the flush 734 * lock without sleeping, then there must not have been 735 * anyone in the process of flushing the inode. 736 */ 737 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || 738 iip->ili_format.ilf_fields != 0); 739 740 /* 741 * Push the inode to it's backing buffer. This will not remove the 742 * inode from the AIL - a further push will be required to trigger a 743 * buffer push. However, this allows all the dirty inodes to be pushed 744 * to the buffer before it is pushed to disk. THe buffer IO completion 745 * will pull th einode from the AIL, mark it clean and unlock the flush 746 * lock. 747 */ 748 (void) xfs_iflush(ip, 0); 749 xfs_iunlock(ip, XFS_ILOCK_SHARED); 750 } 751 752 /* 753 * XXX rcc - this one really has to do something. Probably needs 754 * to stamp in a new field in the incore inode. 755 */ 756 STATIC void 757 xfs_inode_item_committing( 758 struct xfs_log_item *lip, 759 xfs_lsn_t lsn) 760 { 761 INODE_ITEM(lip)->ili_last_lsn = lsn; 762 } 763 764 /* 765 * This is the ops vector shared by all buf log items. 766 */ 767 static struct xfs_item_ops xfs_inode_item_ops = { 768 .iop_size = xfs_inode_item_size, 769 .iop_format = xfs_inode_item_format, 770 .iop_pin = xfs_inode_item_pin, 771 .iop_unpin = xfs_inode_item_unpin, 772 .iop_trylock = xfs_inode_item_trylock, 773 .iop_unlock = xfs_inode_item_unlock, 774 .iop_committed = xfs_inode_item_committed, 775 .iop_push = xfs_inode_item_push, 776 .iop_pushbuf = xfs_inode_item_pushbuf, 777 .iop_committing = xfs_inode_item_committing 778 }; 779 780 781 /* 782 * Initialize the inode log item for a newly allocated (in-core) inode. 783 */ 784 void 785 xfs_inode_item_init( 786 struct xfs_inode *ip, 787 struct xfs_mount *mp) 788 { 789 struct xfs_inode_log_item *iip; 790 791 ASSERT(ip->i_itemp == NULL); 792 iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP); 793 794 iip->ili_inode = ip; 795 xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE, 796 &xfs_inode_item_ops); 797 iip->ili_format.ilf_type = XFS_LI_INODE; 798 iip->ili_format.ilf_ino = ip->i_ino; 799 iip->ili_format.ilf_blkno = ip->i_imap.im_blkno; 800 iip->ili_format.ilf_len = ip->i_imap.im_len; 801 iip->ili_format.ilf_boffset = ip->i_imap.im_boffset; 802 } 803 804 /* 805 * Free the inode log item and any memory hanging off of it. 806 */ 807 void 808 xfs_inode_item_destroy( 809 xfs_inode_t *ip) 810 { 811 #ifdef XFS_TRANS_DEBUG 812 if (ip->i_itemp->ili_root_size != 0) { 813 kmem_free(ip->i_itemp->ili_orig_root); 814 } 815 #endif 816 kmem_zone_free(xfs_ili_zone, ip->i_itemp); 817 } 818 819 820 /* 821 * This is the inode flushing I/O completion routine. It is called 822 * from interrupt level when the buffer containing the inode is 823 * flushed to disk. It is responsible for removing the inode item 824 * from the AIL if it has not been re-logged, and unlocking the inode's 825 * flush lock. 826 */ 827 void 828 xfs_iflush_done( 829 struct xfs_buf *bp, 830 struct xfs_log_item *lip) 831 { 832 struct xfs_inode_log_item *iip = INODE_ITEM(lip); 833 xfs_inode_t *ip = iip->ili_inode; 834 struct xfs_ail *ailp = lip->li_ailp; 835 836 /* 837 * We only want to pull the item from the AIL if it is 838 * actually there and its location in the log has not 839 * changed since we started the flush. Thus, we only bother 840 * if the ili_logged flag is set and the inode's lsn has not 841 * changed. First we check the lsn outside 842 * the lock since it's cheaper, and then we recheck while 843 * holding the lock before removing the inode from the AIL. 844 */ 845 if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn) { 846 spin_lock(&ailp->xa_lock); 847 if (lip->li_lsn == iip->ili_flush_lsn) { 848 /* xfs_trans_ail_delete() drops the AIL lock. */ 849 xfs_trans_ail_delete(ailp, lip); 850 } else { 851 spin_unlock(&ailp->xa_lock); 852 } 853 } 854 855 iip->ili_logged = 0; 856 857 /* 858 * Clear the ili_last_fields bits now that we know that the 859 * data corresponding to them is safely on disk. 860 */ 861 iip->ili_last_fields = 0; 862 863 /* 864 * Release the inode's flush lock since we're done with it. 865 */ 866 xfs_ifunlock(ip); 867 } 868 869 /* 870 * This is the inode flushing abort routine. It is called 871 * from xfs_iflush when the filesystem is shutting down to clean 872 * up the inode state. 873 * It is responsible for removing the inode item 874 * from the AIL if it has not been re-logged, and unlocking the inode's 875 * flush lock. 876 */ 877 void 878 xfs_iflush_abort( 879 xfs_inode_t *ip) 880 { 881 xfs_inode_log_item_t *iip = ip->i_itemp; 882 883 iip = ip->i_itemp; 884 if (iip) { 885 struct xfs_ail *ailp = iip->ili_item.li_ailp; 886 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) { 887 spin_lock(&ailp->xa_lock); 888 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) { 889 /* xfs_trans_ail_delete() drops the AIL lock. */ 890 xfs_trans_ail_delete(ailp, (xfs_log_item_t *)iip); 891 } else 892 spin_unlock(&ailp->xa_lock); 893 } 894 iip->ili_logged = 0; 895 /* 896 * Clear the ili_last_fields bits now that we know that the 897 * data corresponding to them is safely on disk. 898 */ 899 iip->ili_last_fields = 0; 900 /* 901 * Clear the inode logging fields so no more flushes are 902 * attempted. 903 */ 904 iip->ili_format.ilf_fields = 0; 905 } 906 /* 907 * Release the inode's flush lock since we're done with it. 908 */ 909 xfs_ifunlock(ip); 910 } 911 912 void 913 xfs_istale_done( 914 struct xfs_buf *bp, 915 struct xfs_log_item *lip) 916 { 917 xfs_iflush_abort(INODE_ITEM(lip)->ili_inode); 918 } 919 920 /* 921 * convert an xfs_inode_log_format struct from either 32 or 64 bit versions 922 * (which can have different field alignments) to the native version 923 */ 924 int 925 xfs_inode_item_format_convert( 926 xfs_log_iovec_t *buf, 927 xfs_inode_log_format_t *in_f) 928 { 929 if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) { 930 xfs_inode_log_format_32_t *in_f32 = buf->i_addr; 931 932 in_f->ilf_type = in_f32->ilf_type; 933 in_f->ilf_size = in_f32->ilf_size; 934 in_f->ilf_fields = in_f32->ilf_fields; 935 in_f->ilf_asize = in_f32->ilf_asize; 936 in_f->ilf_dsize = in_f32->ilf_dsize; 937 in_f->ilf_ino = in_f32->ilf_ino; 938 /* copy biggest field of ilf_u */ 939 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits, 940 in_f32->ilf_u.ilfu_uuid.__u_bits, 941 sizeof(uuid_t)); 942 in_f->ilf_blkno = in_f32->ilf_blkno; 943 in_f->ilf_len = in_f32->ilf_len; 944 in_f->ilf_boffset = in_f32->ilf_boffset; 945 return 0; 946 } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){ 947 xfs_inode_log_format_64_t *in_f64 = buf->i_addr; 948 949 in_f->ilf_type = in_f64->ilf_type; 950 in_f->ilf_size = in_f64->ilf_size; 951 in_f->ilf_fields = in_f64->ilf_fields; 952 in_f->ilf_asize = in_f64->ilf_asize; 953 in_f->ilf_dsize = in_f64->ilf_dsize; 954 in_f->ilf_ino = in_f64->ilf_ino; 955 /* copy biggest field of ilf_u */ 956 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits, 957 in_f64->ilf_u.ilfu_uuid.__u_bits, 958 sizeof(uuid_t)); 959 in_f->ilf_blkno = in_f64->ilf_blkno; 960 in_f->ilf_len = in_f64->ilf_len; 961 in_f->ilf_boffset = in_f64->ilf_boffset; 962 return 0; 963 } 964 return EFSCORRUPTED; 965 } 966