1 /* 2 * Copyright (C) 2016 Oracle. All Rights Reserved. 3 * 4 * Author: Darrick J. Wong <darrick.wong@oracle.com> 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 8 * as published by the Free Software Foundation; either version 2 9 * of the License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it would be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. 19 */ 20 #include "xfs.h" 21 #include "xfs_fs.h" 22 #include "xfs_format.h" 23 #include "xfs_log_format.h" 24 #include "xfs_trans_resv.h" 25 #include "xfs_bit.h" 26 #include "xfs_shared.h" 27 #include "xfs_mount.h" 28 #include "xfs_defer.h" 29 #include "xfs_trans.h" 30 #include "xfs_trans_priv.h" 31 #include "xfs_buf_item.h" 32 #include "xfs_rmap_item.h" 33 #include "xfs_log.h" 34 #include "xfs_rmap.h" 35 36 37 kmem_zone_t *xfs_rui_zone; 38 kmem_zone_t *xfs_rud_zone; 39 40 static inline struct xfs_rui_log_item *RUI_ITEM(struct xfs_log_item *lip) 41 { 42 return container_of(lip, struct xfs_rui_log_item, rui_item); 43 } 44 45 void 46 xfs_rui_item_free( 47 struct xfs_rui_log_item *ruip) 48 { 49 if (ruip->rui_format.rui_nextents > XFS_RUI_MAX_FAST_EXTENTS) 50 kmem_free(ruip); 51 else 52 kmem_zone_free(xfs_rui_zone, ruip); 53 } 54 55 /* 56 * Freeing the RUI requires that we remove it from the AIL if it has already 57 * been placed there. However, the RUI may not yet have been placed in the AIL 58 * when called by xfs_rui_release() from RUD processing due to the ordering of 59 * committed vs unpin operations in bulk insert operations. Hence the reference 60 * count to ensure only the last caller frees the RUI. 61 */ 62 void 63 xfs_rui_release( 64 struct xfs_rui_log_item *ruip) 65 { 66 ASSERT(atomic_read(&ruip->rui_refcount) > 0); 67 if (atomic_dec_and_test(&ruip->rui_refcount)) { 68 xfs_trans_ail_remove(&ruip->rui_item, SHUTDOWN_LOG_IO_ERROR); 69 xfs_rui_item_free(ruip); 70 } 71 } 72 73 STATIC void 74 xfs_rui_item_size( 75 struct xfs_log_item *lip, 76 int *nvecs, 77 int *nbytes) 78 { 79 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 80 81 *nvecs += 1; 82 *nbytes += xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents); 83 } 84 85 /* 86 * This is called to fill in the vector of log iovecs for the 87 * given rui log item. We use only 1 iovec, and we point that 88 * at the rui_log_format structure embedded in the rui item. 89 * It is at this point that we assert that all of the extent 90 * slots in the rui item have been filled. 91 */ 92 STATIC void 93 xfs_rui_item_format( 94 struct xfs_log_item *lip, 95 struct xfs_log_vec *lv) 96 { 97 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 98 struct xfs_log_iovec *vecp = NULL; 99 100 ASSERT(atomic_read(&ruip->rui_next_extent) == 101 ruip->rui_format.rui_nextents); 102 103 ruip->rui_format.rui_type = XFS_LI_RUI; 104 ruip->rui_format.rui_size = 1; 105 106 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUI_FORMAT, &ruip->rui_format, 107 xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents)); 108 } 109 110 /* 111 * Pinning has no meaning for an rui item, so just return. 112 */ 113 STATIC void 114 xfs_rui_item_pin( 115 struct xfs_log_item *lip) 116 { 117 } 118 119 /* 120 * The unpin operation is the last place an RUI is manipulated in the log. It is 121 * either inserted in the AIL or aborted in the event of a log I/O error. In 122 * either case, the RUI transaction has been successfully committed to make it 123 * this far. Therefore, we expect whoever committed the RUI to either construct 124 * and commit the RUD or drop the RUD's reference in the event of error. Simply 125 * drop the log's RUI reference now that the log is done with it. 126 */ 127 STATIC void 128 xfs_rui_item_unpin( 129 struct xfs_log_item *lip, 130 int remove) 131 { 132 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 133 134 xfs_rui_release(ruip); 135 } 136 137 /* 138 * RUI items have no locking or pushing. However, since RUIs are pulled from 139 * the AIL when their corresponding RUDs are committed to disk, their situation 140 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller 141 * will eventually flush the log. This should help in getting the RUI out of 142 * the AIL. 143 */ 144 STATIC uint 145 xfs_rui_item_push( 146 struct xfs_log_item *lip, 147 struct list_head *buffer_list) 148 { 149 return XFS_ITEM_PINNED; 150 } 151 152 /* 153 * The RUI has been either committed or aborted if the transaction has been 154 * cancelled. If the transaction was cancelled, an RUD isn't going to be 155 * constructed and thus we free the RUI here directly. 156 */ 157 STATIC void 158 xfs_rui_item_unlock( 159 struct xfs_log_item *lip) 160 { 161 if (lip->li_flags & XFS_LI_ABORTED) 162 xfs_rui_release(RUI_ITEM(lip)); 163 } 164 165 /* 166 * The RUI is logged only once and cannot be moved in the log, so simply return 167 * the lsn at which it's been logged. 168 */ 169 STATIC xfs_lsn_t 170 xfs_rui_item_committed( 171 struct xfs_log_item *lip, 172 xfs_lsn_t lsn) 173 { 174 return lsn; 175 } 176 177 /* 178 * The RUI dependency tracking op doesn't do squat. It can't because 179 * it doesn't know where the free extent is coming from. The dependency 180 * tracking has to be handled by the "enclosing" metadata object. For 181 * example, for inodes, the inode is locked throughout the extent freeing 182 * so the dependency should be recorded there. 183 */ 184 STATIC void 185 xfs_rui_item_committing( 186 struct xfs_log_item *lip, 187 xfs_lsn_t lsn) 188 { 189 } 190 191 /* 192 * This is the ops vector shared by all rui log items. 193 */ 194 static const struct xfs_item_ops xfs_rui_item_ops = { 195 .iop_size = xfs_rui_item_size, 196 .iop_format = xfs_rui_item_format, 197 .iop_pin = xfs_rui_item_pin, 198 .iop_unpin = xfs_rui_item_unpin, 199 .iop_unlock = xfs_rui_item_unlock, 200 .iop_committed = xfs_rui_item_committed, 201 .iop_push = xfs_rui_item_push, 202 .iop_committing = xfs_rui_item_committing, 203 }; 204 205 /* 206 * Allocate and initialize an rui item with the given number of extents. 207 */ 208 struct xfs_rui_log_item * 209 xfs_rui_init( 210 struct xfs_mount *mp, 211 uint nextents) 212 213 { 214 struct xfs_rui_log_item *ruip; 215 216 ASSERT(nextents > 0); 217 if (nextents > XFS_RUI_MAX_FAST_EXTENTS) 218 ruip = kmem_zalloc(xfs_rui_log_item_sizeof(nextents), KM_SLEEP); 219 else 220 ruip = kmem_zone_zalloc(xfs_rui_zone, KM_SLEEP); 221 222 xfs_log_item_init(mp, &ruip->rui_item, XFS_LI_RUI, &xfs_rui_item_ops); 223 ruip->rui_format.rui_nextents = nextents; 224 ruip->rui_format.rui_id = (uintptr_t)(void *)ruip; 225 atomic_set(&ruip->rui_next_extent, 0); 226 atomic_set(&ruip->rui_refcount, 2); 227 228 return ruip; 229 } 230 231 /* 232 * Copy an RUI format buffer from the given buf, and into the destination 233 * RUI format structure. The RUI/RUD items were designed not to need any 234 * special alignment handling. 235 */ 236 int 237 xfs_rui_copy_format( 238 struct xfs_log_iovec *buf, 239 struct xfs_rui_log_format *dst_rui_fmt) 240 { 241 struct xfs_rui_log_format *src_rui_fmt; 242 uint len; 243 244 src_rui_fmt = buf->i_addr; 245 len = xfs_rui_log_format_sizeof(src_rui_fmt->rui_nextents); 246 247 if (buf->i_len != len) 248 return -EFSCORRUPTED; 249 250 memcpy(dst_rui_fmt, src_rui_fmt, len); 251 return 0; 252 } 253 254 static inline struct xfs_rud_log_item *RUD_ITEM(struct xfs_log_item *lip) 255 { 256 return container_of(lip, struct xfs_rud_log_item, rud_item); 257 } 258 259 STATIC void 260 xfs_rud_item_size( 261 struct xfs_log_item *lip, 262 int *nvecs, 263 int *nbytes) 264 { 265 *nvecs += 1; 266 *nbytes += sizeof(struct xfs_rud_log_format); 267 } 268 269 /* 270 * This is called to fill in the vector of log iovecs for the 271 * given rud log item. We use only 1 iovec, and we point that 272 * at the rud_log_format structure embedded in the rud item. 273 * It is at this point that we assert that all of the extent 274 * slots in the rud item have been filled. 275 */ 276 STATIC void 277 xfs_rud_item_format( 278 struct xfs_log_item *lip, 279 struct xfs_log_vec *lv) 280 { 281 struct xfs_rud_log_item *rudp = RUD_ITEM(lip); 282 struct xfs_log_iovec *vecp = NULL; 283 284 rudp->rud_format.rud_type = XFS_LI_RUD; 285 rudp->rud_format.rud_size = 1; 286 287 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUD_FORMAT, &rudp->rud_format, 288 sizeof(struct xfs_rud_log_format)); 289 } 290 291 /* 292 * Pinning has no meaning for an rud item, so just return. 293 */ 294 STATIC void 295 xfs_rud_item_pin( 296 struct xfs_log_item *lip) 297 { 298 } 299 300 /* 301 * Since pinning has no meaning for an rud item, unpinning does 302 * not either. 303 */ 304 STATIC void 305 xfs_rud_item_unpin( 306 struct xfs_log_item *lip, 307 int remove) 308 { 309 } 310 311 /* 312 * There isn't much you can do to push on an rud item. It is simply stuck 313 * waiting for the log to be flushed to disk. 314 */ 315 STATIC uint 316 xfs_rud_item_push( 317 struct xfs_log_item *lip, 318 struct list_head *buffer_list) 319 { 320 return XFS_ITEM_PINNED; 321 } 322 323 /* 324 * The RUD is either committed or aborted if the transaction is cancelled. If 325 * the transaction is cancelled, drop our reference to the RUI and free the 326 * RUD. 327 */ 328 STATIC void 329 xfs_rud_item_unlock( 330 struct xfs_log_item *lip) 331 { 332 struct xfs_rud_log_item *rudp = RUD_ITEM(lip); 333 334 if (lip->li_flags & XFS_LI_ABORTED) { 335 xfs_rui_release(rudp->rud_ruip); 336 kmem_zone_free(xfs_rud_zone, rudp); 337 } 338 } 339 340 /* 341 * When the rud item is committed to disk, all we need to do is delete our 342 * reference to our partner rui item and then free ourselves. Since we're 343 * freeing ourselves we must return -1 to keep the transaction code from 344 * further referencing this item. 345 */ 346 STATIC xfs_lsn_t 347 xfs_rud_item_committed( 348 struct xfs_log_item *lip, 349 xfs_lsn_t lsn) 350 { 351 struct xfs_rud_log_item *rudp = RUD_ITEM(lip); 352 353 /* 354 * Drop the RUI reference regardless of whether the RUD has been 355 * aborted. Once the RUD transaction is constructed, it is the sole 356 * responsibility of the RUD to release the RUI (even if the RUI is 357 * aborted due to log I/O error). 358 */ 359 xfs_rui_release(rudp->rud_ruip); 360 kmem_zone_free(xfs_rud_zone, rudp); 361 362 return (xfs_lsn_t)-1; 363 } 364 365 /* 366 * The RUD dependency tracking op doesn't do squat. It can't because 367 * it doesn't know where the free extent is coming from. The dependency 368 * tracking has to be handled by the "enclosing" metadata object. For 369 * example, for inodes, the inode is locked throughout the extent freeing 370 * so the dependency should be recorded there. 371 */ 372 STATIC void 373 xfs_rud_item_committing( 374 struct xfs_log_item *lip, 375 xfs_lsn_t lsn) 376 { 377 } 378 379 /* 380 * This is the ops vector shared by all rud log items. 381 */ 382 static const struct xfs_item_ops xfs_rud_item_ops = { 383 .iop_size = xfs_rud_item_size, 384 .iop_format = xfs_rud_item_format, 385 .iop_pin = xfs_rud_item_pin, 386 .iop_unpin = xfs_rud_item_unpin, 387 .iop_unlock = xfs_rud_item_unlock, 388 .iop_committed = xfs_rud_item_committed, 389 .iop_push = xfs_rud_item_push, 390 .iop_committing = xfs_rud_item_committing, 391 }; 392 393 /* 394 * Allocate and initialize an rud item with the given number of extents. 395 */ 396 struct xfs_rud_log_item * 397 xfs_rud_init( 398 struct xfs_mount *mp, 399 struct xfs_rui_log_item *ruip) 400 401 { 402 struct xfs_rud_log_item *rudp; 403 404 rudp = kmem_zone_zalloc(xfs_rud_zone, KM_SLEEP); 405 xfs_log_item_init(mp, &rudp->rud_item, XFS_LI_RUD, &xfs_rud_item_ops); 406 rudp->rud_ruip = ruip; 407 rudp->rud_format.rud_rui_id = ruip->rui_format.rui_id; 408 409 return rudp; 410 } 411 412 /* 413 * Process an rmap update intent item that was recovered from the log. 414 * We need to update the rmapbt. 415 */ 416 int 417 xfs_rui_recover( 418 struct xfs_mount *mp, 419 struct xfs_rui_log_item *ruip) 420 { 421 int i; 422 int error = 0; 423 struct xfs_map_extent *rmap; 424 xfs_fsblock_t startblock_fsb; 425 bool op_ok; 426 struct xfs_rud_log_item *rudp; 427 enum xfs_rmap_intent_type type; 428 int whichfork; 429 xfs_exntst_t state; 430 struct xfs_trans *tp; 431 struct xfs_btree_cur *rcur = NULL; 432 433 ASSERT(!test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags)); 434 435 /* 436 * First check the validity of the extents described by the 437 * RUI. If any are bad, then assume that all are bad and 438 * just toss the RUI. 439 */ 440 for (i = 0; i < ruip->rui_format.rui_nextents; i++) { 441 rmap = &ruip->rui_format.rui_extents[i]; 442 startblock_fsb = XFS_BB_TO_FSB(mp, 443 XFS_FSB_TO_DADDR(mp, rmap->me_startblock)); 444 switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) { 445 case XFS_RMAP_EXTENT_MAP: 446 case XFS_RMAP_EXTENT_MAP_SHARED: 447 case XFS_RMAP_EXTENT_UNMAP: 448 case XFS_RMAP_EXTENT_UNMAP_SHARED: 449 case XFS_RMAP_EXTENT_CONVERT: 450 case XFS_RMAP_EXTENT_CONVERT_SHARED: 451 case XFS_RMAP_EXTENT_ALLOC: 452 case XFS_RMAP_EXTENT_FREE: 453 op_ok = true; 454 break; 455 default: 456 op_ok = false; 457 break; 458 } 459 if (!op_ok || startblock_fsb == 0 || 460 rmap->me_len == 0 || 461 startblock_fsb >= mp->m_sb.sb_dblocks || 462 rmap->me_len >= mp->m_sb.sb_agblocks || 463 (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS)) { 464 /* 465 * This will pull the RUI from the AIL and 466 * free the memory associated with it. 467 */ 468 set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags); 469 xfs_rui_release(ruip); 470 return -EIO; 471 } 472 } 473 474 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 475 mp->m_rmap_maxlevels, 0, XFS_TRANS_RESERVE, &tp); 476 if (error) 477 return error; 478 rudp = xfs_trans_get_rud(tp, ruip); 479 480 for (i = 0; i < ruip->rui_format.rui_nextents; i++) { 481 rmap = &ruip->rui_format.rui_extents[i]; 482 state = (rmap->me_flags & XFS_RMAP_EXTENT_UNWRITTEN) ? 483 XFS_EXT_UNWRITTEN : XFS_EXT_NORM; 484 whichfork = (rmap->me_flags & XFS_RMAP_EXTENT_ATTR_FORK) ? 485 XFS_ATTR_FORK : XFS_DATA_FORK; 486 switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) { 487 case XFS_RMAP_EXTENT_MAP: 488 type = XFS_RMAP_MAP; 489 break; 490 case XFS_RMAP_EXTENT_MAP_SHARED: 491 type = XFS_RMAP_MAP_SHARED; 492 break; 493 case XFS_RMAP_EXTENT_UNMAP: 494 type = XFS_RMAP_UNMAP; 495 break; 496 case XFS_RMAP_EXTENT_UNMAP_SHARED: 497 type = XFS_RMAP_UNMAP_SHARED; 498 break; 499 case XFS_RMAP_EXTENT_CONVERT: 500 type = XFS_RMAP_CONVERT; 501 break; 502 case XFS_RMAP_EXTENT_CONVERT_SHARED: 503 type = XFS_RMAP_CONVERT_SHARED; 504 break; 505 case XFS_RMAP_EXTENT_ALLOC: 506 type = XFS_RMAP_ALLOC; 507 break; 508 case XFS_RMAP_EXTENT_FREE: 509 type = XFS_RMAP_FREE; 510 break; 511 default: 512 error = -EFSCORRUPTED; 513 goto abort_error; 514 } 515 error = xfs_trans_log_finish_rmap_update(tp, rudp, type, 516 rmap->me_owner, whichfork, 517 rmap->me_startoff, rmap->me_startblock, 518 rmap->me_len, state, &rcur); 519 if (error) 520 goto abort_error; 521 522 } 523 524 xfs_rmap_finish_one_cleanup(tp, rcur, error); 525 set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags); 526 error = xfs_trans_commit(tp); 527 return error; 528 529 abort_error: 530 xfs_rmap_finish_one_cleanup(tp, rcur, error); 531 xfs_trans_cancel(tp); 532 return error; 533 } 534