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_trans_res            resv;
 481         struct xfs_cui_log_item         *cuip = CUI_ITEM(lip);
 482         struct xfs_cud_log_item         *cudp;
 483         struct xfs_trans                *tp;
 484         struct xfs_btree_cur            *rcur = NULL;
 485         struct xfs_mount                *mp = lip->li_log->l_mp;
 486         unsigned int                    refc_type;
 487         bool                            requeue_only = false;
 488         int                             i;
 489         int                             error = 0;
 490
 491         /*
 492          * First check the validity of the extents described by the
 493          * CUI.  If any are bad, then assume that all are bad and
 494          * just toss the CUI.
 495          */
 496         for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
 497                 if (!xfs_cui_validate_phys(mp,
 498                                         &cuip->cui_format.cui_extents[i])) {
 499                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 500                                         &cuip->cui_format,
 501                                         sizeof(cuip->cui_format));
 502                         return -EFSCORRUPTED;
 503                 }
 504         }
 505
 506         /*
 507          * Under normal operation, refcount updates are deferred, so we
 508          * wouldn't be adding them directly to a transaction.  All
 509          * refcount updates manage reservation usage internally and
 510          * dynamically by deferring work that won't fit in the
 511          * transaction.  Normally, any work that needs to be deferred
 512          * gets attached to the same defer_ops that scheduled the
 513          * refcount update.  However, we're in log recovery here, so we
 514          * use the passed in defer_ops and to finish up any work that
 515          * doesn't fit.  We need to reserve enough blocks to handle a
 516          * full btree split on either end of the refcount range.
 517          */
 518         resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
 519         error = xfs_trans_alloc(mp, &resv, mp->m_refc_maxlevels * 2, 0,
 520                         XFS_TRANS_RESERVE, &tp);
 521         if (error)
 522                 return error;
 523
 524         cudp = xfs_trans_get_cud(tp, cuip);
 525
 526         for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
 527                 struct xfs_refcount_intent      fake = { };
 528                 struct xfs_phys_extent          *pmap;
 529
 530                 pmap = &cuip->cui_format.cui_extents[i];
 531                 refc_type = pmap->pe_flags & XFS_REFCOUNT_EXTENT_TYPE_MASK;
 532                 switch (refc_type) {
 533                 case XFS_REFCOUNT_INCREASE:
 534                 case XFS_REFCOUNT_DECREASE:
 535                 case XFS_REFCOUNT_ALLOC_COW:
 536                 case XFS_REFCOUNT_FREE_COW:
 537                         fake.ri_type = refc_type;
 538                         break;
 539                 default:
 540                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 541                                         &cuip->cui_format,
 542                                         sizeof(cuip->cui_format));
 543                         error = -EFSCORRUPTED;
 544                         goto abort_error;
 545                 }
 546
 547                 fake.ri_startblock = pmap->pe_startblock;
 548                 fake.ri_blockcount = pmap->pe_len;
 549
 550                 if (!requeue_only) {
 551                         xfs_refcount_update_get_group(mp, &fake);
 552                         error = xfs_trans_log_finish_refcount_update(tp, cudp,
 553                                         &fake, &rcur);
 554                         xfs_refcount_update_put_group(&fake);
 555                 }
 556                 if (error == -EFSCORRUPTED)
 557                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 558                                         &cuip->cui_format,
 559                                         sizeof(cuip->cui_format));
 560                 if (error)
 561                         goto abort_error;
 562
 563                 /* Requeue what we didn't finish. */
 564                 if (fake.ri_blockcount > 0) {
 565                         struct xfs_bmbt_irec    irec = {
 566                                 .br_startblock  = fake.ri_startblock,
 567                                 .br_blockcount  = fake.ri_blockcount,
 568                         };
 569
 570                         switch (fake.ri_type) {
 571                         case XFS_REFCOUNT_INCREASE:
 572                                 xfs_refcount_increase_extent(tp, &irec);
 573                                 break;
 574                         case XFS_REFCOUNT_DECREASE:
 575                                 xfs_refcount_decrease_extent(tp, &irec);
 576                                 break;
 577                         case XFS_REFCOUNT_ALLOC_COW:
 578                                 xfs_refcount_alloc_cow_extent(tp,
 579                                                 irec.br_startblock,
 580                                                 irec.br_blockcount);
 581                                 break;
 582                         case XFS_REFCOUNT_FREE_COW:
 583                                 xfs_refcount_free_cow_extent(tp,
 584                                                 irec.br_startblock,
 585                                                 irec.br_blockcount);
 586                                 break;
 587                         default:
 588                                 ASSERT(0);
 589                         }
 590                         requeue_only = true;
 591                 }
 592         }
 593
 594         xfs_refcount_finish_one_cleanup(tp, rcur, error);
 595         return xfs_defer_ops_capture_and_commit(tp, capture_list);
 596
 597 abort_error:
 598         xfs_refcount_finish_one_cleanup(tp, rcur, error);
 599         xfs_trans_cancel(tp);
 600         return error;
 601 }
 602
 603 STATIC bool
 604 xfs_cui_item_match(
 605         struct xfs_log_item     *lip,
 606         uint64_t                intent_id)
 607 {
 608         return CUI_ITEM(lip)->cui_format.cui_id == intent_id;
 609 }
 610
 611 /* Relog an intent item to push the log tail forward. */
 612 static struct xfs_log_item *
 613 xfs_cui_item_relog(
 614         struct xfs_log_item             *intent,
 615         struct xfs_trans                *tp)
 616 {
 617         struct xfs_cud_log_item         *cudp;
 618         struct xfs_cui_log_item         *cuip;
 619         struct xfs_phys_extent          *pmap;
 620         unsigned int                    count;
 621
 622         count = CUI_ITEM(intent)->cui_format.cui_nextents;
 623         pmap = CUI_ITEM(intent)->cui_format.cui_extents;
 624
 625         tp->t_flags |= XFS_TRANS_DIRTY;
 626         cudp = xfs_trans_get_cud(tp, CUI_ITEM(intent));
 627         set_bit(XFS_LI_DIRTY, &cudp->cud_item.li_flags);
 628
 629         cuip = xfs_cui_init(tp->t_mountp, count);
 630         memcpy(cuip->cui_format.cui_extents, pmap, count * sizeof(*pmap));
 631         atomic_set(&cuip->cui_next_extent, count);
 632         xfs_trans_add_item(tp, &cuip->cui_item);
 633         set_bit(XFS_LI_DIRTY, &cuip->cui_item.li_flags);
 634         return &cuip->cui_item;
 635 }
 636
 637 static const struct xfs_item_ops xfs_cui_item_ops = {
 638         .flags          = XFS_ITEM_INTENT,
 639         .iop_size       = xfs_cui_item_size,
 640         .iop_format     = xfs_cui_item_format,
 641         .iop_unpin      = xfs_cui_item_unpin,
 642         .iop_release    = xfs_cui_item_release,
 643         .iop_recover    = xfs_cui_item_recover,
 644         .iop_match      = xfs_cui_item_match,
 645         .iop_relog      = xfs_cui_item_relog,
 646 };
 647
 648 static inline void
 649 xfs_cui_copy_format(
 650         struct xfs_cui_log_format       *dst,
 651         const struct xfs_cui_log_format *src)
 652 {
 653         unsigned int                    i;
 654
 655         memcpy(dst, src, offsetof(struct xfs_cui_log_format, cui_extents));
 656
 657         for (i = 0; i < src->cui_nextents; i++)
 658                 memcpy(&dst->cui_extents[i], &src->cui_extents[i],
 659                                 sizeof(struct xfs_phys_extent));
 660 }
 661
 662 /*
 663  * This routine is called to create an in-core extent refcount update
 664  * item from the cui format structure which was logged on disk.
 665  * It allocates an in-core cui, copies the extents from the format
 666  * structure into it, and adds the cui to the AIL with the given
 667  * LSN.
 668  */
 669 STATIC int
 670 xlog_recover_cui_commit_pass2(
 671         struct xlog                     *log,
 672         struct list_head                *buffer_list,
 673         struct xlog_recover_item        *item,
 674         xfs_lsn_t                       lsn)
 675 {
 676         struct xfs_mount                *mp = log->l_mp;
 677         struct xfs_cui_log_item         *cuip;
 678         struct xfs_cui_log_format       *cui_formatp;
 679         size_t                          len;
 680
 681         cui_formatp = item->ri_buf[0].i_addr;
 682
 683         if (item->ri_buf[0].i_len < xfs_cui_log_format_sizeof(0)) {
 684                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 685                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 686                 return -EFSCORRUPTED;
 687         }
 688
 689         len = xfs_cui_log_format_sizeof(cui_formatp->cui_nextents);
 690         if (item->ri_buf[0].i_len != len) {
 691                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 692                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 693                 return -EFSCORRUPTED;
 694         }
 695
 696         cuip = xfs_cui_init(mp, cui_formatp->cui_nextents);
 697         xfs_cui_copy_format(&cuip->cui_format, cui_formatp);
 698         atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents);
 699         /*
 700          * Insert the intent into the AIL directly and drop one reference so
 701          * that finishing or canceling the work will drop the other.
 702          */
 703         xfs_trans_ail_insert(log->l_ailp, &cuip->cui_item, lsn);
 704         xfs_cui_release(cuip);
 705         return 0;
 706 }
 707
 708 const struct xlog_recover_item_ops xlog_cui_item_ops = {
 709         .item_type              = XFS_LI_CUI,
 710         .commit_pass2           = xlog_recover_cui_commit_pass2,
 711 };
 712
 713 /*
 714  * This routine is called when an CUD format structure is found in a committed
 715  * transaction in the log. Its purpose is to cancel the corresponding CUI if it
 716  * was still in the log. To do this it searches the AIL for the CUI with an id
 717  * equal to that in the CUD format structure. If we find it we drop the CUD
 718  * reference, which removes the CUI from the AIL and frees it.
 719  */
 720 STATIC int
 721 xlog_recover_cud_commit_pass2(
 722         struct xlog                     *log,
 723         struct list_head                *buffer_list,
 724         struct xlog_recover_item        *item,
 725         xfs_lsn_t                       lsn)
 726 {
 727         struct xfs_cud_log_format       *cud_formatp;
 728
 729         cud_formatp = item->ri_buf[0].i_addr;
 730         if (item->ri_buf[0].i_len != sizeof(struct xfs_cud_log_format)) {
 731                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
 732                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 733                 return -EFSCORRUPTED;
 734         }
 735
 736         xlog_recover_release_intent(log, XFS_LI_CUI, cud_formatp->cud_cui_id);
 737         return 0;
 738 }
 739
 740 const struct xlog_recover_item_ops xlog_cud_item_ops = {
 741         .item_type              = XFS_LI_CUD,
 742         .commit_pass2           = xlog_recover_cud_commit_pass2,
 743 };