fs/xfs/xfs_refcount_item.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2016 Oracle.  All Rights Reserved.
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_format.h"
   9 #include "xfs_log_format.h"
  10 #include "xfs_trans_resv.h"
  11 #include "xfs_bit.h"
  12 #include "xfs_shared.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_defer.h"
  15 #include "xfs_trans.h"
  16 #include "xfs_trans_priv.h"
  17 #include "xfs_refcount_item.h"
  18 #include "xfs_log.h"
  19 #include "xfs_refcount.h"
  20 #include "xfs_error.h"
  21 #include "xfs_log_priv.h"
  22 #include "xfs_log_recover.h"
  23 #include "xfs_ag.h"
  24
  25 struct kmem_cache       *xfs_cui_cache;
  26 struct kmem_cache       *xfs_cud_cache;
  27
  28 static const struct xfs_item_ops xfs_cui_item_ops;
  29
  30 static inline struct xfs_cui_log_item *CUI_ITEM(struct xfs_log_item *lip)
  31 {
  32         return container_of(lip, struct xfs_cui_log_item, cui_item);
  33 }
  34
  35 STATIC void
  36 xfs_cui_item_free(
  37         struct xfs_cui_log_item *cuip)
  38 {
  39         kmem_free(cuip->cui_item.li_lv_shadow);
  40         if (cuip->cui_format.cui_nextents > XFS_CUI_MAX_FAST_EXTENTS)
  41                 kmem_free(cuip);
  42         else
  43                 kmem_cache_free(xfs_cui_cache, cuip);
  44 }
  45
  46 /*
  47  * Freeing the CUI requires that we remove it from the AIL if it has already
  48  * been placed there. However, the CUI may not yet have been placed in the AIL
  49  * when called by xfs_cui_release() from CUD processing due to the ordering of
  50  * committed vs unpin operations in bulk insert operations. Hence the reference
  51  * count to ensure only the last caller frees the CUI.
  52  */
  53 STATIC void
  54 xfs_cui_release(
  55         struct xfs_cui_log_item *cuip)
  56 {
  57         ASSERT(atomic_read(&cuip->cui_refcount) > 0);
  58         if (!atomic_dec_and_test(&cuip->cui_refcount))
  59                 return;
  60
  61         xfs_trans_ail_delete(&cuip->cui_item, 0);
  62         xfs_cui_item_free(cuip);
  63 }
  64
  65
  66 STATIC void
  67 xfs_cui_item_size(
  68         struct xfs_log_item     *lip,
  69         int                     *nvecs,
  70         int                     *nbytes)
  71 {
  72         struct xfs_cui_log_item *cuip = CUI_ITEM(lip);
  73
  74         *nvecs += 1;
  75         *nbytes += xfs_cui_log_format_sizeof(cuip->cui_format.cui_nextents);
  76 }
  77
  78 /*
  79  * This is called to fill in the vector of log iovecs for the
  80  * given cui log item. We use only 1 iovec, and we point that
  81  * at the cui_log_format structure embedded in the cui item.
  82  * It is at this point that we assert that all of the extent
  83  * slots in the cui item have been filled.
  84  */
  85 STATIC void
  86 xfs_cui_item_format(
  87         struct xfs_log_item     *lip,
  88         struct xfs_log_vec      *lv)
  89 {
  90         struct xfs_cui_log_item *cuip = CUI_ITEM(lip);
  91         struct xfs_log_iovec    *vecp = NULL;
  92
  93         ASSERT(atomic_read(&cuip->cui_next_extent) ==
  94                         cuip->cui_format.cui_nextents);
  95
  96         cuip->cui_format.cui_type = XFS_LI_CUI;
  97         cuip->cui_format.cui_size = 1;
  98
  99         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_CUI_FORMAT, &cuip->cui_format,
 100                         xfs_cui_log_format_sizeof(cuip->cui_format.cui_nextents));
 101 }
 102
 103 /*
 104  * The unpin operation is the last place an CUI is manipulated in the log. It is
 105  * either inserted in the AIL or aborted in the event of a log I/O error. In
 106  * either case, the CUI transaction has been successfully committed to make it
 107  * this far. Therefore, we expect whoever committed the CUI to either construct
 108  * and commit the CUD or drop the CUD's reference in the event of error. Simply
 109  * drop the log's CUI reference now that the log is done with it.
 110  */
 111 STATIC void
 112 xfs_cui_item_unpin(
 113         struct xfs_log_item     *lip,
 114         int                     remove)
 115 {
 116         struct xfs_cui_log_item *cuip = CUI_ITEM(lip);
 117
 118         xfs_cui_release(cuip);
 119 }
 120
 121 /*
 122  * The CUI has been either committed or aborted if the transaction has been
 123  * cancelled. If the transaction was cancelled, an CUD isn't going to be
 124  * constructed and thus we free the CUI here directly.
 125  */
 126 STATIC void
 127 xfs_cui_item_release(
 128         struct xfs_log_item     *lip)
 129 {
 130         xfs_cui_release(CUI_ITEM(lip));
 131 }
 132
 133 /*
 134  * Allocate and initialize an cui item with the given number of extents.
 135  */
 136 STATIC struct xfs_cui_log_item *
 137 xfs_cui_init(
 138         struct xfs_mount                *mp,
 139         uint                            nextents)
 140
 141 {
 142         struct xfs_cui_log_item         *cuip;
 143
 144         ASSERT(nextents > 0);
 145         if (nextents > XFS_CUI_MAX_FAST_EXTENTS)
 146                 cuip = kmem_zalloc(xfs_cui_log_item_sizeof(nextents),
 147                                 0);
 148         else
 149                 cuip = kmem_cache_zalloc(xfs_cui_cache,
 150                                          GFP_KERNEL | __GFP_NOFAIL);
 151
 152         xfs_log_item_init(mp, &cuip->cui_item, XFS_LI_CUI, &xfs_cui_item_ops);
 153         cuip->cui_format.cui_nextents = nextents;
 154         cuip->cui_format.cui_id = (uintptr_t)(void *)cuip;
 155         atomic_set(&cuip->cui_next_extent, 0);
 156         atomic_set(&cuip->cui_refcount, 2);
 157
 158         return cuip;
 159 }
 160
 161 static inline struct xfs_cud_log_item *CUD_ITEM(struct xfs_log_item *lip)
 162 {
 163         return container_of(lip, struct xfs_cud_log_item, cud_item);
 164 }
 165
 166 STATIC void
 167 xfs_cud_item_size(
 168         struct xfs_log_item     *lip,
 169         int                     *nvecs,
 170         int                     *nbytes)
 171 {
 172         *nvecs += 1;
 173         *nbytes += sizeof(struct xfs_cud_log_format);
 174 }
 175
 176 /*
 177  * This is called to fill in the vector of log iovecs for the
 178  * given cud log item. We use only 1 iovec, and we point that
 179  * at the cud_log_format structure embedded in the cud item.
 180  * It is at this point that we assert that all of the extent
 181  * slots in the cud item have been filled.
 182  */
 183 STATIC void
 184 xfs_cud_item_format(
 185         struct xfs_log_item     *lip,
 186         struct xfs_log_vec      *lv)
 187 {
 188         struct xfs_cud_log_item *cudp = CUD_ITEM(lip);
 189         struct xfs_log_iovec    *vecp = NULL;
 190
 191         cudp->cud_format.cud_type = XFS_LI_CUD;
 192         cudp->cud_format.cud_size = 1;
 193
 194         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_CUD_FORMAT, &cudp->cud_format,
 195                         sizeof(struct xfs_cud_log_format));
 196 }
 197
 198 /*
 199  * The CUD is either committed or aborted if the transaction is cancelled. If
 200  * the transaction is cancelled, drop our reference to the CUI and free the
 201  * CUD.
 202  */
 203 STATIC void
 204 xfs_cud_item_release(
 205         struct xfs_log_item     *lip)
 206 {
 207         struct xfs_cud_log_item *cudp = CUD_ITEM(lip);
 208
 209         xfs_cui_release(cudp->cud_cuip);
 210         kmem_free(cudp->cud_item.li_lv_shadow);
 211         kmem_cache_free(xfs_cud_cache, cudp);
 212 }
 213
 214 static struct xfs_log_item *
 215 xfs_cud_item_intent(
 216         struct xfs_log_item     *lip)
 217 {
 218         return &CUD_ITEM(lip)->cud_cuip->cui_item;
 219 }
 220
 221 static const struct xfs_item_ops xfs_cud_item_ops = {
 222         .flags          = XFS_ITEM_RELEASE_WHEN_COMMITTED |
 223                           XFS_ITEM_INTENT_DONE,
 224         .iop_size       = xfs_cud_item_size,
 225         .iop_format     = xfs_cud_item_format,
 226         .iop_release    = xfs_cud_item_release,
 227         .iop_intent     = xfs_cud_item_intent,
 228 };
 229
 230 static struct xfs_cud_log_item *
 231 xfs_trans_get_cud(
 232         struct xfs_trans                *tp,
 233         struct xfs_cui_log_item         *cuip)
 234 {
 235         struct xfs_cud_log_item         *cudp;
 236
 237         cudp = kmem_cache_zalloc(xfs_cud_cache, GFP_KERNEL | __GFP_NOFAIL);
 238         xfs_log_item_init(tp->t_mountp, &cudp->cud_item, XFS_LI_CUD,
 239                           &xfs_cud_item_ops);
 240         cudp->cud_cuip = cuip;
 241         cudp->cud_format.cud_cui_id = cuip->cui_format.cui_id;
 242
 243         xfs_trans_add_item(tp, &cudp->cud_item);
 244         return cudp;
 245 }
 246
 247 /*
 248  * Finish an refcount update and log it to the CUD. Note that the
 249  * transaction is marked dirty regardless of whether the refcount
 250  * update succeeds or fails to support the CUI/CUD lifecycle rules.
 251  */
 252 static int
 253 xfs_trans_log_finish_refcount_update(
 254         struct xfs_trans                *tp,
 255         struct xfs_cud_log_item         *cudp,
 256         struct xfs_refcount_intent      *ri,
 257         struct xfs_btree_cur            **pcur)
 258 {
 259         int                             error;
 260
 261         error = xfs_refcount_finish_one(tp, ri, pcur);
 262
 263         /*
 264          * Mark the transaction dirty, even on error. This ensures the
 265          * transaction is aborted, which:
 266          *
 267          * 1.) releases the CUI and frees the CUD
 268          * 2.) shuts down the filesystem
 269          */
 270         tp->t_flags |= XFS_TRANS_DIRTY | XFS_TRANS_HAS_INTENT_DONE;
 271         set_bit(XFS_LI_DIRTY, &cudp->cud_item.li_flags);
 272
 273         return error;
 274 }
 275
 276 /* Sort refcount intents by AG. */
 277 static int
 278 xfs_refcount_update_diff_items(
 279         void                            *priv,
 280         const struct list_head          *a,
 281         const struct list_head          *b)
 282 {
 283         struct xfs_refcount_intent      *ra;
 284         struct xfs_refcount_intent      *rb;
 285
 286         ra = container_of(a, struct xfs_refcount_intent, ri_list);
 287         rb = container_of(b, struct xfs_refcount_intent, ri_list);
 288
 289         return ra->ri_pag->pag_agno - rb->ri_pag->pag_agno;
 290 }
 291
 292 /* Set the phys extent flags for this reverse mapping. */
 293 static void
 294 xfs_trans_set_refcount_flags(
 295         struct xfs_phys_extent          *pmap,
 296         enum xfs_refcount_intent_type   type)
 297 {
 298         pmap->pe_flags = 0;
 299         switch (type) {
 300         case XFS_REFCOUNT_INCREASE:
 301         case XFS_REFCOUNT_DECREASE:
 302         case XFS_REFCOUNT_ALLOC_COW:
 303         case XFS_REFCOUNT_FREE_COW:
 304                 pmap->pe_flags |= type;
 305                 break;
 306         default:
 307                 ASSERT(0);
 308         }
 309 }
 310
 311 /* Log refcount updates in the intent item. */
 312 STATIC void
 313 xfs_refcount_update_log_item(
 314         struct xfs_trans                *tp,
 315         struct xfs_cui_log_item         *cuip,
 316         struct xfs_refcount_intent      *ri)
 317 {
 318         uint                            next_extent;
 319         struct xfs_phys_extent          *pmap;
 320
 321         tp->t_flags |= XFS_TRANS_DIRTY;
 322         set_bit(XFS_LI_DIRTY, &cuip->cui_item.li_flags);
 323
 324         /*
 325          * atomic_inc_return gives us the value after the increment;
 326          * we want to use it as an array index so we need to subtract 1 from
 327          * it.
 328          */
 329         next_extent = atomic_inc_return(&cuip->cui_next_extent) - 1;
 330         ASSERT(next_extent < cuip->cui_format.cui_nextents);
 331         pmap = &cuip->cui_format.cui_extents[next_extent];
 332         pmap->pe_startblock = ri->ri_startblock;
 333         pmap->pe_len = ri->ri_blockcount;
 334         xfs_trans_set_refcount_flags(pmap, ri->ri_type);
 335 }
 336
 337 static struct xfs_log_item *
 338 xfs_refcount_update_create_intent(
 339         struct xfs_trans                *tp,
 340         struct list_head                *items,
 341         unsigned int                    count,
 342         bool                            sort)
 343 {
 344         struct xfs_mount                *mp = tp->t_mountp;
 345         struct xfs_cui_log_item         *cuip = xfs_cui_init(mp, count);
 346         struct xfs_refcount_intent      *ri;
 347
 348         ASSERT(count > 0);
 349
 350         xfs_trans_add_item(tp, &cuip->cui_item);
 351         if (sort)
 352                 list_sort(mp, items, xfs_refcount_update_diff_items);
 353         list_for_each_entry(ri, items, ri_list)
 354                 xfs_refcount_update_log_item(tp, cuip, ri);
 355         return &cuip->cui_item;
 356 }
 357
 358 /* Get an CUD so we can process all the deferred refcount updates. */
 359 static struct xfs_log_item *
 360 xfs_refcount_update_create_done(
 361         struct xfs_trans                *tp,
 362         struct xfs_log_item             *intent,
 363         unsigned int                    count)
 364 {
 365         return &xfs_trans_get_cud(tp, CUI_ITEM(intent))->cud_item;
 366 }
 367
 368 /* Take a passive ref to the AG containing the space we're refcounting. */
 369 void
 370 xfs_refcount_update_get_group(
 371         struct xfs_mount                *mp,
 372         struct xfs_refcount_intent      *ri)
 373 {
 374         xfs_agnumber_t                  agno;
 375
 376         agno = XFS_FSB_TO_AGNO(mp, ri->ri_startblock);
 377         ri->ri_pag = xfs_perag_intent_get(mp, agno);
 378 }
 379
 380 /* Release a passive AG ref after finishing refcounting work. */
 381 static inline void
 382 xfs_refcount_update_put_group(
 383         struct xfs_refcount_intent      *ri)
 384 {
 385         xfs_perag_intent_put(ri->ri_pag);
 386 }
 387
 388 /* Process a deferred refcount update. */
 389 STATIC int
 390 xfs_refcount_update_finish_item(
 391         struct xfs_trans                *tp,
 392         struct xfs_log_item             *done,
 393         struct list_head                *item,
 394         struct xfs_btree_cur            **state)
 395 {
 396         struct xfs_refcount_intent      *ri;
 397         int                             error;
 398
 399         ri = container_of(item, struct xfs_refcount_intent, ri_list);
 400         error = xfs_trans_log_finish_refcount_update(tp, CUD_ITEM(done), ri,
 401                         state);
 402
 403         /* Did we run out of reservation?  Requeue what we didn't finish. */
 404         if (!error && ri->ri_blockcount > 0) {
 405                 ASSERT(ri->ri_type == XFS_REFCOUNT_INCREASE ||
 406                        ri->ri_type == XFS_REFCOUNT_DECREASE);
 407                 return -EAGAIN;
 408         }
 409
 410         xfs_refcount_update_put_group(ri);
 411         kmem_cache_free(xfs_refcount_intent_cache, ri);
 412         return error;
 413 }
 414
 415 /* Abort all pending CUIs. */
 416 STATIC void
 417 xfs_refcount_update_abort_intent(
 418         struct xfs_log_item             *intent)
 419 {
 420         xfs_cui_release(CUI_ITEM(intent));
 421 }
 422
 423 /* Cancel a deferred refcount update. */
 424 STATIC void
 425 xfs_refcount_update_cancel_item(
 426         struct list_head                *item)
 427 {
 428         struct xfs_refcount_intent      *ri;
 429
 430         ri = container_of(item, struct xfs_refcount_intent, ri_list);
 431
 432         xfs_refcount_update_put_group(ri);
 433         kmem_cache_free(xfs_refcount_intent_cache, ri);
 434 }
 435
 436 const struct xfs_defer_op_type xfs_refcount_update_defer_type = {
 437         .max_items      = XFS_CUI_MAX_FAST_EXTENTS,
 438         .create_intent  = xfs_refcount_update_create_intent,
 439         .abort_intent   = xfs_refcount_update_abort_intent,
 440         .create_done    = xfs_refcount_update_create_done,
 441         .finish_item    = xfs_refcount_update_finish_item,
 442         .finish_cleanup = xfs_refcount_finish_one_cleanup,
 443         .cancel_item    = xfs_refcount_update_cancel_item,
 444 };
 445
 446 /* Is this recovered CUI ok? */
 447 static inline bool
 448 xfs_cui_validate_phys(
 449         struct xfs_mount                *mp,
 450         struct xfs_phys_extent          *pmap)
 451 {
 452         if (!xfs_has_reflink(mp))
 453                 return false;
 454
 455         if (pmap->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS)
 456                 return false;
 457
 458         switch (pmap->pe_flags & XFS_REFCOUNT_EXTENT_TYPE_MASK) {
 459         case XFS_REFCOUNT_INCREASE:
 460         case XFS_REFCOUNT_DECREASE:
 461         case XFS_REFCOUNT_ALLOC_COW:
 462         case XFS_REFCOUNT_FREE_COW:
 463                 break;
 464         default:
 465                 return false;
 466         }
 467
 468         return xfs_verify_fsbext(mp, pmap->pe_startblock, pmap->pe_len);
 469 }
 470
 471 /*
 472  * Process a refcount update intent item that was recovered from the log.
 473  * We need to update the refcountbt.
 474  */
 475 STATIC int
 476 xfs_cui_item_recover(
 477         struct xfs_log_item             *lip,
 478         struct list_head                *capture_list)
 479 {
 480         struct xfs_cui_log_item         *cuip = CUI_ITEM(lip);
 481         struct xfs_cud_log_item         *cudp;
 482         struct xfs_trans                *tp;
 483         struct xfs_btree_cur            *rcur = NULL;
 484         struct xfs_mount                *mp = lip->li_log->l_mp;
 485         unsigned int                    refc_type;
 486         bool                            requeue_only = false;
 487         int                             i;
 488         int                             error = 0;
 489
 490         /*
 491          * First check the validity of the extents described by the
 492          * CUI.  If any are bad, then assume that all are bad and
 493          * just toss the CUI.
 494          */
 495         for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
 496                 if (!xfs_cui_validate_phys(mp,
 497                                         &cuip->cui_format.cui_extents[i])) {
 498                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 499                                         &cuip->cui_format,
 500                                         sizeof(cuip->cui_format));
 501                         return -EFSCORRUPTED;
 502                 }
 503         }
 504
 505         /*
 506          * Under normal operation, refcount updates are deferred, so we
 507          * wouldn't be adding them directly to a transaction.  All
 508          * refcount updates manage reservation usage internally and
 509          * dynamically by deferring work that won't fit in the
 510          * transaction.  Normally, any work that needs to be deferred
 511          * gets attached to the same defer_ops that scheduled the
 512          * refcount update.  However, we're in log recovery here, so we
 513          * use the passed in defer_ops and to finish up any work that
 514          * doesn't fit.  We need to reserve enough blocks to handle a
 515          * full btree split on either end of the refcount range.
 516          */
 517         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
 518                         mp->m_refc_maxlevels * 2, 0, XFS_TRANS_RESERVE, &tp);
 519         if (error)
 520                 return error;
 521
 522         cudp = xfs_trans_get_cud(tp, cuip);
 523
 524         for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
 525                 struct xfs_refcount_intent      fake = { };
 526                 struct xfs_phys_extent          *pmap;
 527
 528                 pmap = &cuip->cui_format.cui_extents[i];
 529                 refc_type = pmap->pe_flags & XFS_REFCOUNT_EXTENT_TYPE_MASK;
 530                 switch (refc_type) {
 531                 case XFS_REFCOUNT_INCREASE:
 532                 case XFS_REFCOUNT_DECREASE:
 533                 case XFS_REFCOUNT_ALLOC_COW:
 534                 case XFS_REFCOUNT_FREE_COW:
 535                         fake.ri_type = refc_type;
 536                         break;
 537                 default:
 538                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 539                                         &cuip->cui_format,
 540                                         sizeof(cuip->cui_format));
 541                         error = -EFSCORRUPTED;
 542                         goto abort_error;
 543                 }
 544
 545                 fake.ri_startblock = pmap->pe_startblock;
 546                 fake.ri_blockcount = pmap->pe_len;
 547
 548                 if (!requeue_only) {
 549                         xfs_refcount_update_get_group(mp, &fake);
 550                         error = xfs_trans_log_finish_refcount_update(tp, cudp,
 551                                         &fake, &rcur);
 552                         xfs_refcount_update_put_group(&fake);
 553                 }
 554                 if (error == -EFSCORRUPTED)
 555                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 556                                         &cuip->cui_format,
 557                                         sizeof(cuip->cui_format));
 558                 if (error)
 559                         goto abort_error;
 560
 561                 /* Requeue what we didn't finish. */
 562                 if (fake.ri_blockcount > 0) {
 563                         struct xfs_bmbt_irec    irec = {
 564                                 .br_startblock  = fake.ri_startblock,
 565                                 .br_blockcount  = fake.ri_blockcount,
 566                         };
 567
 568                         switch (fake.ri_type) {
 569                         case XFS_REFCOUNT_INCREASE:
 570                                 xfs_refcount_increase_extent(tp, &irec);
 571                                 break;
 572                         case XFS_REFCOUNT_DECREASE:
 573                                 xfs_refcount_decrease_extent(tp, &irec);
 574                                 break;
 575                         case XFS_REFCOUNT_ALLOC_COW:
 576                                 xfs_refcount_alloc_cow_extent(tp,
 577                                                 irec.br_startblock,
 578                                                 irec.br_blockcount);
 579                                 break;
 580                         case XFS_REFCOUNT_FREE_COW:
 581                                 xfs_refcount_free_cow_extent(tp,
 582                                                 irec.br_startblock,
 583                                                 irec.br_blockcount);
 584                                 break;
 585                         default:
 586                                 ASSERT(0);
 587                         }
 588                         requeue_only = true;
 589                 }
 590         }
 591
 592         xfs_refcount_finish_one_cleanup(tp, rcur, error);
 593         return xfs_defer_ops_capture_and_commit(tp, capture_list);
 594
 595 abort_error:
 596         xfs_refcount_finish_one_cleanup(tp, rcur, error);
 597         xfs_trans_cancel(tp);
 598         return error;
 599 }
 600
 601 STATIC bool
 602 xfs_cui_item_match(
 603         struct xfs_log_item     *lip,
 604         uint64_t                intent_id)
 605 {
 606         return CUI_ITEM(lip)->cui_format.cui_id == intent_id;
 607 }
 608
 609 /* Relog an intent item to push the log tail forward. */
 610 static struct xfs_log_item *
 611 xfs_cui_item_relog(
 612         struct xfs_log_item             *intent,
 613         struct xfs_trans                *tp)
 614 {
 615         struct xfs_cud_log_item         *cudp;
 616         struct xfs_cui_log_item         *cuip;
 617         struct xfs_phys_extent          *pmap;
 618         unsigned int                    count;
 619
 620         count = CUI_ITEM(intent)->cui_format.cui_nextents;
 621         pmap = CUI_ITEM(intent)->cui_format.cui_extents;
 622
 623         tp->t_flags |= XFS_TRANS_DIRTY;
 624         cudp = xfs_trans_get_cud(tp, CUI_ITEM(intent));
 625         set_bit(XFS_LI_DIRTY, &cudp->cud_item.li_flags);
 626
 627         cuip = xfs_cui_init(tp->t_mountp, count);
 628         memcpy(cuip->cui_format.cui_extents, pmap, count * sizeof(*pmap));
 629         atomic_set(&cuip->cui_next_extent, count);
 630         xfs_trans_add_item(tp, &cuip->cui_item);
 631         set_bit(XFS_LI_DIRTY, &cuip->cui_item.li_flags);
 632         return &cuip->cui_item;
 633 }
 634
 635 static const struct xfs_item_ops xfs_cui_item_ops = {
 636         .flags          = XFS_ITEM_INTENT,
 637         .iop_size       = xfs_cui_item_size,
 638         .iop_format     = xfs_cui_item_format,
 639         .iop_unpin      = xfs_cui_item_unpin,
 640         .iop_release    = xfs_cui_item_release,
 641         .iop_recover    = xfs_cui_item_recover,
 642         .iop_match      = xfs_cui_item_match,
 643         .iop_relog      = xfs_cui_item_relog,
 644 };
 645
 646 static inline void
 647 xfs_cui_copy_format(
 648         struct xfs_cui_log_format       *dst,
 649         const struct xfs_cui_log_format *src)
 650 {
 651         unsigned int                    i;
 652
 653         memcpy(dst, src, offsetof(struct xfs_cui_log_format, cui_extents));
 654
 655         for (i = 0; i < src->cui_nextents; i++)
 656                 memcpy(&dst->cui_extents[i], &src->cui_extents[i],
 657                                 sizeof(struct xfs_phys_extent));
 658 }
 659
 660 /*
 661  * This routine is called to create an in-core extent refcount update
 662  * item from the cui format structure which was logged on disk.
 663  * It allocates an in-core cui, copies the extents from the format
 664  * structure into it, and adds the cui to the AIL with the given
 665  * LSN.
 666  */
 667 STATIC int
 668 xlog_recover_cui_commit_pass2(
 669         struct xlog                     *log,
 670         struct list_head                *buffer_list,
 671         struct xlog_recover_item        *item,
 672         xfs_lsn_t                       lsn)
 673 {
 674         struct xfs_mount                *mp = log->l_mp;
 675         struct xfs_cui_log_item         *cuip;
 676         struct xfs_cui_log_format       *cui_formatp;
 677         size_t                          len;
 678
 679         cui_formatp = item->ri_buf[0].i_addr;
 680
 681         if (item->ri_buf[0].i_len < xfs_cui_log_format_sizeof(0)) {
 682                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 683                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 684                 return -EFSCORRUPTED;
 685         }
 686
 687         len = xfs_cui_log_format_sizeof(cui_formatp->cui_nextents);
 688         if (item->ri_buf[0].i_len != len) {
 689                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 690                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 691                 return -EFSCORRUPTED;
 692         }
 693
 694         cuip = xfs_cui_init(mp, cui_formatp->cui_nextents);
 695         xfs_cui_copy_format(&cuip->cui_format, cui_formatp);
 696         atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents);
 697         /*
 698          * Insert the intent into the AIL directly and drop one reference so
 699          * that finishing or canceling the work will drop the other.
 700          */
 701         xfs_trans_ail_insert(log->l_ailp, &cuip->cui_item, lsn);
 702         xfs_cui_release(cuip);
 703         return 0;
 704 }
 705
 706 const struct xlog_recover_item_ops xlog_cui_item_ops = {
 707         .item_type              = XFS_LI_CUI,
 708         .commit_pass2           = xlog_recover_cui_commit_pass2,
 709 };
 710
 711 /*
 712  * This routine is called when an CUD format structure is found in a committed
 713  * transaction in the log. Its purpose is to cancel the corresponding CUI if it
 714  * was still in the log. To do this it searches the AIL for the CUI with an id
 715  * equal to that in the CUD format structure. If we find it we drop the CUD
 716  * reference, which removes the CUI from the AIL and frees it.
 717  */
 718 STATIC int
 719 xlog_recover_cud_commit_pass2(
 720         struct xlog                     *log,
 721         struct list_head                *buffer_list,
 722         struct xlog_recover_item        *item,
 723         xfs_lsn_t                       lsn)
 724 {
 725         struct xfs_cud_log_format       *cud_formatp;
 726
 727         cud_formatp = item->ri_buf[0].i_addr;
 728         if (item->ri_buf[0].i_len != sizeof(struct xfs_cud_log_format)) {
 729                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
 730                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 731                 return -EFSCORRUPTED;
 732         }
 733
 734         xlog_recover_release_intent(log, XFS_LI_CUI, cud_formatp->cud_cui_id);
 735         return 0;
 736 }
 737
 738 const struct xlog_recover_item_ops xlog_cud_item_ops = {
 739         .item_type              = XFS_LI_CUD,
 740         .commit_pass2           = xlog_recover_cud_commit_pass2,
 741 };