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 STATIC void 56 xfs_rui_item_size( 57 struct xfs_log_item *lip, 58 int *nvecs, 59 int *nbytes) 60 { 61 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 62 63 *nvecs += 1; 64 *nbytes += xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents); 65 } 66 67 /* 68 * This is called to fill in the vector of log iovecs for the 69 * given rui log item. We use only 1 iovec, and we point that 70 * at the rui_log_format structure embedded in the rui item. 71 * It is at this point that we assert that all of the extent 72 * slots in the rui item have been filled. 73 */ 74 STATIC void 75 xfs_rui_item_format( 76 struct xfs_log_item *lip, 77 struct xfs_log_vec *lv) 78 { 79 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 80 struct xfs_log_iovec *vecp = NULL; 81 82 ASSERT(atomic_read(&ruip->rui_next_extent) == 83 ruip->rui_format.rui_nextents); 84 85 ruip->rui_format.rui_type = XFS_LI_RUI; 86 ruip->rui_format.rui_size = 1; 87 88 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUI_FORMAT, &ruip->rui_format, 89 xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents)); 90 } 91 92 /* 93 * Pinning has no meaning for an rui item, so just return. 94 */ 95 STATIC void 96 xfs_rui_item_pin( 97 struct xfs_log_item *lip) 98 { 99 } 100 101 /* 102 * The unpin operation is the last place an RUI is manipulated in the log. It is 103 * either inserted in the AIL or aborted in the event of a log I/O error. In 104 * either case, the RUI transaction has been successfully committed to make it 105 * this far. Therefore, we expect whoever committed the RUI to either construct 106 * and commit the RUD or drop the RUD's reference in the event of error. Simply 107 * drop the log's RUI reference now that the log is done with it. 108 */ 109 STATIC void 110 xfs_rui_item_unpin( 111 struct xfs_log_item *lip, 112 int remove) 113 { 114 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 115 116 xfs_rui_release(ruip); 117 } 118 119 /* 120 * RUI items have no locking or pushing. However, since RUIs are pulled from 121 * the AIL when their corresponding RUDs are committed to disk, their situation 122 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller 123 * will eventually flush the log. This should help in getting the RUI out of 124 * the AIL. 125 */ 126 STATIC uint 127 xfs_rui_item_push( 128 struct xfs_log_item *lip, 129 struct list_head *buffer_list) 130 { 131 return XFS_ITEM_PINNED; 132 } 133 134 /* 135 * The RUI has been either committed or aborted if the transaction has been 136 * cancelled. If the transaction was cancelled, an RUD isn't going to be 137 * constructed and thus we free the RUI here directly. 138 */ 139 STATIC void 140 xfs_rui_item_unlock( 141 struct xfs_log_item *lip) 142 { 143 if (lip->li_flags & XFS_LI_ABORTED) 144 xfs_rui_item_free(RUI_ITEM(lip)); 145 } 146 147 /* 148 * The RUI is logged only once and cannot be moved in the log, so simply return 149 * the lsn at which it's been logged. 150 */ 151 STATIC xfs_lsn_t 152 xfs_rui_item_committed( 153 struct xfs_log_item *lip, 154 xfs_lsn_t lsn) 155 { 156 return lsn; 157 } 158 159 /* 160 * The RUI dependency tracking op doesn't do squat. It can't because 161 * it doesn't know where the free extent is coming from. The dependency 162 * tracking has to be handled by the "enclosing" metadata object. For 163 * example, for inodes, the inode is locked throughout the extent freeing 164 * so the dependency should be recorded there. 165 */ 166 STATIC void 167 xfs_rui_item_committing( 168 struct xfs_log_item *lip, 169 xfs_lsn_t lsn) 170 { 171 } 172 173 /* 174 * This is the ops vector shared by all rui log items. 175 */ 176 static const struct xfs_item_ops xfs_rui_item_ops = { 177 .iop_size = xfs_rui_item_size, 178 .iop_format = xfs_rui_item_format, 179 .iop_pin = xfs_rui_item_pin, 180 .iop_unpin = xfs_rui_item_unpin, 181 .iop_unlock = xfs_rui_item_unlock, 182 .iop_committed = xfs_rui_item_committed, 183 .iop_push = xfs_rui_item_push, 184 .iop_committing = xfs_rui_item_committing, 185 }; 186 187 /* 188 * Allocate and initialize an rui item with the given number of extents. 189 */ 190 struct xfs_rui_log_item * 191 xfs_rui_init( 192 struct xfs_mount *mp, 193 uint nextents) 194 195 { 196 struct xfs_rui_log_item *ruip; 197 198 ASSERT(nextents > 0); 199 if (nextents > XFS_RUI_MAX_FAST_EXTENTS) 200 ruip = kmem_zalloc(xfs_rui_log_item_sizeof(nextents), KM_SLEEP); 201 else 202 ruip = kmem_zone_zalloc(xfs_rui_zone, KM_SLEEP); 203 204 xfs_log_item_init(mp, &ruip->rui_item, XFS_LI_RUI, &xfs_rui_item_ops); 205 ruip->rui_format.rui_nextents = nextents; 206 ruip->rui_format.rui_id = (uintptr_t)(void *)ruip; 207 atomic_set(&ruip->rui_next_extent, 0); 208 atomic_set(&ruip->rui_refcount, 2); 209 210 return ruip; 211 } 212 213 /* 214 * Copy an RUI format buffer from the given buf, and into the destination 215 * RUI format structure. The RUI/RUD items were designed not to need any 216 * special alignment handling. 217 */ 218 int 219 xfs_rui_copy_format( 220 struct xfs_log_iovec *buf, 221 struct xfs_rui_log_format *dst_rui_fmt) 222 { 223 struct xfs_rui_log_format *src_rui_fmt; 224 uint len; 225 226 src_rui_fmt = buf->i_addr; 227 len = xfs_rui_log_format_sizeof(src_rui_fmt->rui_nextents); 228 229 if (buf->i_len != len) 230 return -EFSCORRUPTED; 231 232 memcpy(dst_rui_fmt, src_rui_fmt, len); 233 return 0; 234 } 235 236 /* 237 * Freeing the RUI requires that we remove it from the AIL if it has already 238 * been placed there. However, the RUI may not yet have been placed in the AIL 239 * when called by xfs_rui_release() from RUD processing due to the ordering of 240 * committed vs unpin operations in bulk insert operations. Hence the reference 241 * count to ensure only the last caller frees the RUI. 242 */ 243 void 244 xfs_rui_release( 245 struct xfs_rui_log_item *ruip) 246 { 247 ASSERT(atomic_read(&ruip->rui_refcount) > 0); 248 if (atomic_dec_and_test(&ruip->rui_refcount)) { 249 xfs_trans_ail_remove(&ruip->rui_item, SHUTDOWN_LOG_IO_ERROR); 250 xfs_rui_item_free(ruip); 251 } 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