linux/fs/xfs/xfs_log_cil.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2010 Red Hat, Inc. All Rights Reserved.
   3 *
   4 * This program is free software; you can redistribute it and/or
   5 * modify it under the terms of the GNU General Public License as
   6 * published by the Free Software Foundation.
   7 *
   8 * This program is distributed in the hope that it would be useful,
   9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 * GNU General Public License for more details.
  12 *
  13 * You should have received a copy of the GNU General Public License
  14 * along with this program; if not, write the Free Software Foundation,
  15 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  16 */
  17
  18#include "xfs.h"
  19#include "xfs_fs.h"
  20#include "xfs_types.h"
  21#include "xfs_log.h"
  22#include "xfs_trans.h"
  23#include "xfs_trans_priv.h"
  24#include "xfs_log_priv.h"
  25#include "xfs_sb.h"
  26#include "xfs_ag.h"
  27#include "xfs_mount.h"
  28#include "xfs_error.h"
  29#include "xfs_alloc.h"
  30#include "xfs_extent_busy.h"
  31#include "xfs_discard.h"
  32
  33/*
  34 * Allocate a new ticket. Failing to get a new ticket makes it really hard to
  35 * recover, so we don't allow failure here. Also, we allocate in a context that
  36 * we don't want to be issuing transactions from, so we need to tell the
  37 * allocation code this as well.
  38 *
  39 * We don't reserve any space for the ticket - we are going to steal whatever
  40 * space we require from transactions as they commit. To ensure we reserve all
  41 * the space required, we need to set the current reservation of the ticket to
  42 * zero so that we know to steal the initial transaction overhead from the
  43 * first transaction commit.
  44 */
  45static struct xlog_ticket *
  46xlog_cil_ticket_alloc(
  47        struct xlog     *log)
  48{
  49        struct xlog_ticket *tic;
  50
  51        tic = xlog_ticket_alloc(log, 0, 1, XFS_TRANSACTION, 0,
  52                                KM_SLEEP|KM_NOFS);
  53        tic->t_trans_type = XFS_TRANS_CHECKPOINT;
  54
  55        /*
  56         * set the current reservation to zero so we know to steal the basic
  57         * transaction overhead reservation from the first transaction commit.
  58         */
  59        tic->t_curr_res = 0;
  60        return tic;
  61}
  62
  63/*
  64 * After the first stage of log recovery is done, we know where the head and
  65 * tail of the log are. We need this log initialisation done before we can
  66 * initialise the first CIL checkpoint context.
  67 *
  68 * Here we allocate a log ticket to track space usage during a CIL push.  This
  69 * ticket is passed to xlog_write() directly so that we don't slowly leak log
  70 * space by failing to account for space used by log headers and additional
  71 * region headers for split regions.
  72 */
  73void
  74xlog_cil_init_post_recovery(
  75        struct xlog     *log)
  76{
  77        log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
  78        log->l_cilp->xc_ctx->sequence = 1;
  79        log->l_cilp->xc_ctx->commit_lsn = xlog_assign_lsn(log->l_curr_cycle,
  80                                                                log->l_curr_block);
  81}
  82
  83/*
  84 * Format log item into a flat buffers
  85 *
  86 * For delayed logging, we need to hold a formatted buffer containing all the
  87 * changes on the log item. This enables us to relog the item in memory and
  88 * write it out asynchronously without needing to relock the object that was
  89 * modified at the time it gets written into the iclog.
  90 *
  91 * This function builds a vector for the changes in each log item in the
  92 * transaction. It then works out the length of the buffer needed for each log
  93 * item, allocates them and formats the vector for the item into the buffer.
  94 * The buffer is then attached to the log item are then inserted into the
  95 * Committed Item List for tracking until the next checkpoint is written out.
  96 *
  97 * We don't set up region headers during this process; we simply copy the
  98 * regions into the flat buffer. We can do this because we still have to do a
  99 * formatting step to write the regions into the iclog buffer.  Writing the
 100 * ophdrs during the iclog write means that we can support splitting large
 101 * regions across iclog boundares without needing a change in the format of the
 102 * item/region encapsulation.
 103 *
 104 * Hence what we need to do now is change the rewrite the vector array to point
 105 * to the copied region inside the buffer we just allocated. This allows us to
 106 * format the regions into the iclog as though they are being formatted
 107 * directly out of the objects themselves.
 108 */
 109static struct xfs_log_vec *
 110xlog_cil_prepare_log_vecs(
 111        struct xfs_trans        *tp)
 112{
 113        struct xfs_log_item_desc *lidp;
 114        struct xfs_log_vec      *lv = NULL;
 115        struct xfs_log_vec      *ret_lv = NULL;
 116
 117
 118        /* Bail out if we didn't find a log item.  */
 119        if (list_empty(&tp->t_items)) {
 120                ASSERT(0);
 121                return NULL;
 122        }
 123
 124        list_for_each_entry(lidp, &tp->t_items, lid_trans) {
 125                struct xfs_log_vec *new_lv;
 126                void    *ptr;
 127                int     index;
 128                int     len = 0;
 129                uint    niovecs;
 130
 131                /* Skip items which aren't dirty in this transaction. */
 132                if (!(lidp->lid_flags & XFS_LID_DIRTY))
 133                        continue;
 134
 135                /* Skip items that do not have any vectors for writing */
 136                niovecs = IOP_SIZE(lidp->lid_item);
 137                if (!niovecs)
 138                        continue;
 139
 140                new_lv = kmem_zalloc(sizeof(*new_lv) +
 141                                niovecs * sizeof(struct xfs_log_iovec),
 142                                KM_SLEEP);
 143
 144                /* The allocated iovec region lies beyond the log vector. */
 145                new_lv->lv_iovecp = (struct xfs_log_iovec *)&new_lv[1];
 146                new_lv->lv_niovecs = niovecs;
 147                new_lv->lv_item = lidp->lid_item;
 148
 149                /* build the vector array and calculate it's length */
 150                IOP_FORMAT(new_lv->lv_item, new_lv->lv_iovecp);
 151                for (index = 0; index < new_lv->lv_niovecs; index++)
 152                        len += new_lv->lv_iovecp[index].i_len;
 153
 154                new_lv->lv_buf_len = len;
 155                new_lv->lv_buf = kmem_alloc(new_lv->lv_buf_len,
 156                                KM_SLEEP|KM_NOFS);
 157                ptr = new_lv->lv_buf;
 158
 159                for (index = 0; index < new_lv->lv_niovecs; index++) {
 160                        struct xfs_log_iovec *vec = &new_lv->lv_iovecp[index];
 161
 162                        memcpy(ptr, vec->i_addr, vec->i_len);
 163                        vec->i_addr = ptr;
 164                        ptr += vec->i_len;
 165                }
 166                ASSERT(ptr == new_lv->lv_buf + new_lv->lv_buf_len);
 167
 168                if (!ret_lv)
 169                        ret_lv = new_lv;
 170                else
 171                        lv->lv_next = new_lv;
 172                lv = new_lv;
 173        }
 174
 175        return ret_lv;
 176}
 177
 178/*
 179 * Prepare the log item for insertion into the CIL. Calculate the difference in
 180 * log space and vectors it will consume, and if it is a new item pin it as
 181 * well.
 182 */
 183STATIC void
 184xfs_cil_prepare_item(
 185        struct xlog             *log,
 186        struct xfs_log_vec      *lv,
 187        int                     *len,
 188        int                     *diff_iovecs)
 189{
 190        struct xfs_log_vec      *old = lv->lv_item->li_lv;
 191
 192        if (old) {
 193                /* existing lv on log item, space used is a delta */
 194                ASSERT(!list_empty(&lv->lv_item->li_cil));
 195                ASSERT(old->lv_buf && old->lv_buf_len && old->lv_niovecs);
 196
 197                *len += lv->lv_buf_len - old->lv_buf_len;
 198                *diff_iovecs += lv->lv_niovecs - old->lv_niovecs;
 199                kmem_free(old->lv_buf);
 200                kmem_free(old);
 201        } else {
 202                /* new lv, must pin the log item */
 203                ASSERT(!lv->lv_item->li_lv);
 204                ASSERT(list_empty(&lv->lv_item->li_cil));
 205
 206                *len += lv->lv_buf_len;
 207                *diff_iovecs += lv->lv_niovecs;
 208                IOP_PIN(lv->lv_item);
 209
 210        }
 211
 212        /* attach new log vector to log item */
 213        lv->lv_item->li_lv = lv;
 214
 215        /*
 216         * If this is the first time the item is being committed to the
 217         * CIL, store the sequence number on the log item so we can
 218         * tell in future commits whether this is the first checkpoint
 219         * the item is being committed into.
 220         */
 221        if (!lv->lv_item->li_seq)
 222                lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;
 223}
 224
 225/*
 226 * Insert the log items into the CIL and calculate the difference in space
 227 * consumed by the item. Add the space to the checkpoint ticket and calculate
 228 * if the change requires additional log metadata. If it does, take that space
 229 * as well. Remove the amount of space we added to the checkpoint ticket from
 230 * the current transaction ticket so that the accounting works out correctly.
 231 */
 232static void
 233xlog_cil_insert_items(
 234        struct xlog             *log,
 235        struct xfs_log_vec      *log_vector,
 236        struct xlog_ticket      *ticket)
 237{
 238        struct xfs_cil          *cil = log->l_cilp;
 239        struct xfs_cil_ctx      *ctx = cil->xc_ctx;
 240        struct xfs_log_vec      *lv;
 241        int                     len = 0;
 242        int                     diff_iovecs = 0;
 243        int                     iclog_space;
 244
 245        ASSERT(log_vector);
 246
 247        /*
 248         * Do all the accounting aggregation and switching of log vectors
 249         * around in a separate loop to the insertion of items into the CIL.
 250         * Then we can do a separate loop to update the CIL within a single
 251         * lock/unlock pair. This reduces the number of round trips on the CIL
 252         * lock from O(nr_logvectors) to O(1) and greatly reduces the overall
 253         * hold time for the transaction commit.
 254         *
 255         * If this is the first time the item is being placed into the CIL in
 256         * this context, pin it so it can't be written to disk until the CIL is
 257         * flushed to the iclog and the iclog written to disk.
 258         *
 259         * We can do this safely because the context can't checkpoint until we
 260         * are done so it doesn't matter exactly how we update the CIL.
 261         */
 262        for (lv = log_vector; lv; lv = lv->lv_next)
 263                xfs_cil_prepare_item(log, lv, &len, &diff_iovecs);
 264
 265        /* account for space used by new iovec headers  */
 266        len += diff_iovecs * sizeof(xlog_op_header_t);
 267
 268        spin_lock(&cil->xc_cil_lock);
 269
 270        /* move the items to the tail of the CIL */
 271        for (lv = log_vector; lv; lv = lv->lv_next)
 272                list_move_tail(&lv->lv_item->li_cil, &cil->xc_cil);
 273
 274        ctx->nvecs += diff_iovecs;
 275
 276        /*
 277         * Now transfer enough transaction reservation to the context ticket
 278         * for the checkpoint. The context ticket is special - the unit
 279         * reservation has to grow as well as the current reservation as we
 280         * steal from tickets so we can correctly determine the space used
 281         * during the transaction commit.
 282         */
 283        if (ctx->ticket->t_curr_res == 0) {
 284                /* first commit in checkpoint, steal the header reservation */
 285                ASSERT(ticket->t_curr_res >= ctx->ticket->t_unit_res + len);
 286                ctx->ticket->t_curr_res = ctx->ticket->t_unit_res;
 287                ticket->t_curr_res -= ctx->ticket->t_unit_res;
 288        }
 289
 290        /* do we need space for more log record headers? */
 291        iclog_space = log->l_iclog_size - log->l_iclog_hsize;
 292        if (len > 0 && (ctx->space_used / iclog_space !=
 293                                (ctx->space_used + len) / iclog_space)) {
 294                int hdrs;
 295
 296                hdrs = (len + iclog_space - 1) / iclog_space;
 297                /* need to take into account split region headers, too */
 298                hdrs *= log->l_iclog_hsize + sizeof(struct xlog_op_header);
 299                ctx->ticket->t_unit_res += hdrs;
 300                ctx->ticket->t_curr_res += hdrs;
 301                ticket->t_curr_res -= hdrs;
 302                ASSERT(ticket->t_curr_res >= len);
 303        }
 304        ticket->t_curr_res -= len;
 305        ctx->space_used += len;
 306
 307        spin_unlock(&cil->xc_cil_lock);
 308}
 309
 310static void
 311xlog_cil_free_logvec(
 312        struct xfs_log_vec      *log_vector)
 313{
 314        struct xfs_log_vec      *lv;
 315
 316        for (lv = log_vector; lv; ) {
 317                struct xfs_log_vec *next = lv->lv_next;
 318                kmem_free(lv->lv_buf);
 319                kmem_free(lv);
 320                lv = next;
 321        }
 322}
 323
 324/*
 325 * Mark all items committed and clear busy extents. We free the log vector
 326 * chains in a separate pass so that we unpin the log items as quickly as
 327 * possible.
 328 */
 329static void
 330xlog_cil_committed(
 331        void    *args,
 332        int     abort)
 333{
 334        struct xfs_cil_ctx      *ctx = args;
 335        struct xfs_mount        *mp = ctx->cil->xc_log->l_mp;
 336
 337        xfs_trans_committed_bulk(ctx->cil->xc_log->l_ailp, ctx->lv_chain,
 338                                        ctx->start_lsn, abort);
 339
 340        xfs_extent_busy_sort(&ctx->busy_extents);
 341        xfs_extent_busy_clear(mp, &ctx->busy_extents,
 342                             (mp->m_flags & XFS_MOUNT_DISCARD) && !abort);
 343
 344        spin_lock(&ctx->cil->xc_cil_lock);
 345        list_del(&ctx->committing);
 346        spin_unlock(&ctx->cil->xc_cil_lock);
 347
 348        xlog_cil_free_logvec(ctx->lv_chain);
 349
 350        if (!list_empty(&ctx->busy_extents)) {
 351                ASSERT(mp->m_flags & XFS_MOUNT_DISCARD);
 352
 353                xfs_discard_extents(mp, &ctx->busy_extents);
 354                xfs_extent_busy_clear(mp, &ctx->busy_extents, false);
 355        }
 356
 357        kmem_free(ctx);
 358}
 359
 360/*
 361 * Push the Committed Item List to the log. If @push_seq flag is zero, then it
 362 * is a background flush and so we can chose to ignore it. Otherwise, if the
 363 * current sequence is the same as @push_seq we need to do a flush. If
 364 * @push_seq is less than the current sequence, then it has already been
 365 * flushed and we don't need to do anything - the caller will wait for it to
 366 * complete if necessary.
 367 *
 368 * @push_seq is a value rather than a flag because that allows us to do an
 369 * unlocked check of the sequence number for a match. Hence we can allows log
 370 * forces to run racily and not issue pushes for the same sequence twice. If we
 371 * get a race between multiple pushes for the same sequence they will block on
 372 * the first one and then abort, hence avoiding needless pushes.
 373 */
 374STATIC int
 375xlog_cil_push(
 376        struct xlog             *log)
 377{
 378        struct xfs_cil          *cil = log->l_cilp;
 379        struct xfs_log_vec      *lv;
 380        struct xfs_cil_ctx      *ctx;
 381        struct xfs_cil_ctx      *new_ctx;
 382        struct xlog_in_core     *commit_iclog;
 383        struct xlog_ticket      *tic;
 384        int                     num_lv;
 385        int                     num_iovecs;
 386        int                     len;
 387        int                     error = 0;
 388        struct xfs_trans_header thdr;
 389        struct xfs_log_iovec    lhdr;
 390        struct xfs_log_vec      lvhdr = { NULL };
 391        xfs_lsn_t               commit_lsn;
 392        xfs_lsn_t               push_seq;
 393
 394        if (!cil)
 395                return 0;
 396
 397        new_ctx = kmem_zalloc(sizeof(*new_ctx), KM_SLEEP|KM_NOFS);
 398        new_ctx->ticket = xlog_cil_ticket_alloc(log);
 399
 400        down_write(&cil->xc_ctx_lock);
 401        ctx = cil->xc_ctx;
 402
 403        spin_lock(&cil->xc_cil_lock);
 404        push_seq = cil->xc_push_seq;
 405        ASSERT(push_seq <= ctx->sequence);
 406
 407        /*
 408         * Check if we've anything to push. If there is nothing, then we don't
 409         * move on to a new sequence number and so we have to be able to push
 410         * this sequence again later.
 411         */
 412        if (list_empty(&cil->xc_cil)) {
 413                cil->xc_push_seq = 0;
 414                spin_unlock(&cil->xc_cil_lock);
 415                goto out_skip;
 416        }
 417        spin_unlock(&cil->xc_cil_lock);
 418
 419
 420        /* check for a previously pushed seqeunce */
 421        if (push_seq < cil->xc_ctx->sequence)
 422                goto out_skip;
 423
 424        /*
 425         * pull all the log vectors off the items in the CIL, and
 426         * remove the items from the CIL. We don't need the CIL lock
 427         * here because it's only needed on the transaction commit
 428         * side which is currently locked out by the flush lock.
 429         */
 430        lv = NULL;
 431        num_lv = 0;
 432        num_iovecs = 0;
 433        len = 0;
 434        while (!list_empty(&cil->xc_cil)) {
 435                struct xfs_log_item     *item;
 436                int                     i;
 437
 438                item = list_first_entry(&cil->xc_cil,
 439                                        struct xfs_log_item, li_cil);
 440                list_del_init(&item->li_cil);
 441                if (!ctx->lv_chain)
 442                        ctx->lv_chain = item->li_lv;
 443                else
 444                        lv->lv_next = item->li_lv;
 445                lv = item->li_lv;
 446                item->li_lv = NULL;
 447
 448                num_lv++;
 449                num_iovecs += lv->lv_niovecs;
 450                for (i = 0; i < lv->lv_niovecs; i++)
 451                        len += lv->lv_iovecp[i].i_len;
 452        }
 453
 454        /*
 455         * initialise the new context and attach it to the CIL. Then attach
 456         * the current context to the CIL committing lsit so it can be found
 457         * during log forces to extract the commit lsn of the sequence that
 458         * needs to be forced.
 459         */
 460        INIT_LIST_HEAD(&new_ctx->committing);
 461        INIT_LIST_HEAD(&new_ctx->busy_extents);
 462        new_ctx->sequence = ctx->sequence + 1;
 463        new_ctx->cil = cil;
 464        cil->xc_ctx = new_ctx;
 465
 466        /*
 467         * mirror the new sequence into the cil structure so that we can do
 468         * unlocked checks against the current sequence in log forces without
 469         * risking deferencing a freed context pointer.
 470         */
 471        cil->xc_current_sequence = new_ctx->sequence;
 472
 473        /*
 474         * The switch is now done, so we can drop the context lock and move out
 475         * of a shared context. We can't just go straight to the commit record,
 476         * though - we need to synchronise with previous and future commits so
 477         * that the commit records are correctly ordered in the log to ensure
 478         * that we process items during log IO completion in the correct order.
 479         *
 480         * For example, if we get an EFI in one checkpoint and the EFD in the
 481         * next (e.g. due to log forces), we do not want the checkpoint with
 482         * the EFD to be committed before the checkpoint with the EFI.  Hence
 483         * we must strictly order the commit records of the checkpoints so
 484         * that: a) the checkpoint callbacks are attached to the iclogs in the
 485         * correct order; and b) the checkpoints are replayed in correct order
 486         * in log recovery.
 487         *
 488         * Hence we need to add this context to the  name="L473ce we need to add this contexl50heckpoints are r"> 405 mpty(&4fs_log_vec               *
                412        if (pushf="+code=xc_cil_lock" class="sref">xc_cil_lock);
 404        pclass="li4e" name="L394"> 394 4     49 id="L434" class="line" name=ass=mpt+code=li_cil" class=mpt">xc_cil_lock);
 346        ,  346pceckpoint  href="fs/xfs/xfs_log_ci4.c#L349xc_ctx = xc_cil_lock);
 418
push_seq <= xc_cil_lock);
 401        ctx 397 4     4n4w_ctx4=  408         * Check if wew_ctx4> 428<"L389"xfs_losref=i="L362" clasn class="comment"> * complete if necessary4class="li4e" name="L400"> 400 4     49="fs/xfs/xfs_log_cil.c#L482a href="fs/begie="L428"> 4286" id405 mcc class="lips_lous483"yan class="comment">         * correct order5>down_wri5e(& 428<"L389"x.c#L4a79" e" name mcc483a>         *
 = cil50ass="line" name="L412"> 412      lass="comment">         *
2=                
 405 d="L3L362" clasn" id="me=""> 428         *
3=  394 5il" c50ints so
         * side which is5ush_seq = 
 409 481         *
5h_seq96" id="L396" class="li5ass="50rrect order
 407 5     50 class="sref">ctx-> 384        int   + 1;
ctxcil-> 389        struclass="line" nameth_mag4"> 384       h_mag4"nt   + 1;
 35TRANSs" clER_MAGe="L375"> 375> 35TRANSs" clER_MAGe=codeef="+code=ctx" class="sref">ctxticket =  389        struclass="line" nameth_type=xc_ctx_lock" cth_typent   + 1;
 35TRANSsCHECKPOINcode=ctx" class=> 35TRANSsCHECKPOINccodeef="+code=ctx" class="sref">ctx 400 5o be 509"sref">ticket =  389        struclass="line" nameth_tit+code=li_cil" cth_titnt   + 1;
 384        int  3" id="L463" class="t_tit+code=li_cil" ct_titnt  ef="+code=ctx" class="sref">ctx
new_L389"> 389        struclass="line" nameth_"sref id=+code=li_cil" cth_"sref id=ef">sequence;
 386        int                     xc_current_sequL390"> 390        struclass="line" name="mpt0"> 390     ="mpt0ef">seqcil_lock);
 389        struct list5empty(&pushL390"> 390        struclass="line" name="L452"> 452        }
KM_S id="L418" classf389" id="L389">;
;ctxcil5> 390        struclass="line" name="type=xc_ctx_lock" ci_typent   + 1;
LOG_REG_TYPE5TRANSHDRode=ctx" class=>LOG_REG_TYPE5TRANSHDRtruct (& 384        int  3" id="L463" class="t_uenc_re=+code=li_cil" ct_uenc_re=c_ctx-/a>[ 390        struclass="line" name="L452"> 452        }
KM_S id="L418" classog_iop="L389">;
;ctxout_skip;
/*
5417ctx->n5">spin_un5ock(&cil->i_len;
 390        struct  419
5a hre51="sref">ticket = li_lv;
item->li_lvt  420 5     5/* check for a p5eviously 5ushed seqeunce */5new_name="L388"> 388        stru id="L418" classog_i+code=xc_ctx_lock" csog_i+code">xc_>-> 399
 384        int  busy_extents, false);
 392 447
ctxpush_s5q < cil-> 388        s           out_skip;
ticket_alloc(tickett  424 5     5/*
 425         * pull all the 5og vector5 off the items in the CI5, and5/span>
         * pull all the 5o="L417" 5e CIL. We don't need5the C5L lock
 rame="span class="comment">         *

ticket = xc_cil_lock);
 404        5= ,  346 461        lv->e="L425"> 425         * pull all the 5>num_iove5s = 0;
(linesoaref=8clamclass="comment">         *
 = 0;

         *
"fs/xfs/5ist_empty(&xfs_log_item5    *5a href="+code=item" clil->ctx->sequence-/a>);
 406
i;
5='s o5e" name="L438"> 438 5     537href="+code=item" clil)
 392        lis->e="L425"> 425         * pull all the 5>9fs/xfs/5code=xfs_log_item" class5"sref53="fs/xfs/xfs_log_cil.c#L482a href="ffs/xfs_l/xfs_log_cI e" nst2el" c1"> 42! Worrect o * complete if necessary5lass="sre5">list_del_init(&5 09"> 40=tar 11         *
ct5-> 412     fs/xfs_l/xfs_log_  if (->lv_chain = xc_cil_lock);
,  404        5l.c#L444"5id="L444" class="line" n5me="L544"> 444                  d="L423" class="linere=tar _alloc(
ef="+code=push_seq" class="sref">5l"fs/xfs/5v->lv_nexxfs/xfs_log_cil.c#L454" id="L454"5>lv =5item-&gxfs/xfs_log_cil.c#L454" id="L454"5>="L417" 5>->ctx->xc_cil_lock);
 418
 448 5     5        num_5v++;
ticket =  392        xc_>-> 399
 379     mp"L390" class="line" n84"> 384        int  busy_extents,  383        struc, 0ref="+code=ctx" class="sref">ctxii &lil-> 392         += lv->d="L423" class="line" naass="_alloc(5d="L453" 5lass="line" name="L453">5453/*
 454 5     55ss="line" name="L474"> 474 428thi/         3L36    sg_  if ( = item-> 399
 384      cb_fun"   stru id="L418" classog_i
5dlv =5xt and attach it to the 5IL. T55ef">push_seq <= item-> 399
 383;
itef="+code=push_seq" class="sref">5d="L417" 5he CIL committing lsit s5 it c55 class="sref">ctx-> 388        stru id="L418" class class=notif="+code=xc_cil" s class=notif=">xc_>-> 399
 379     mp"L390" class="line" nrs="line" name="L383"> 383        struc, sy_extents, false);
 399
ctxi &lil-> 388        s           
lisd="L423" class="line" naass="_alloc(5d9fs/xfs/5xfs_log_cil.c#L460" id="5460" 55span class="comment">/* check for a p5ref">INIT5LIST_HEAD(&INIT5LIST_HEAD(& xfs_loog_cil.c#L name="L4 class="comment">         * correct order5w_ctx5>
 485         * correct order5wlass="li5>
 class="comment">         *
->
 466 5     56ef">push_seq <= xc_cil_lock);
 404        5="fs/xfs/5fs_log_cil.c#L467" id="L567" c56 class="sref">ctx-> 392         392        5=lass="li5into the cil structure s5 that56 class="sref">cil-> 392xc_cil_lock);
5=ced.ticket = xc_cil_lock);
 418

/* check for a p5f="fs/xfs5xfs_log_cil.c#L471" id="5471" 57="fs/xfs/xfs_log_cil.c#L421" id="L421"releaL456" ihan cs!xf  if (returnu id="L418" class class=releaL4ne" name="L383"> 383xc_>-> 399
 379     mp"L390" class="line" nrs="line" name="L383"> 383        struc/xfs/xfs_log_cil.c#L419" id="L419"5class="li5e" name="L473"> 473 5     5/*
 423
xc_cil_lock);
 401        ctxpush_seq <= xc_>->ctxctx->(xc_>->ctxreturnue (!ticket_alloc(ticket: href="+code=list_empty" class="5f we get 5n EFI in one checkpoint 5nd th58a>;
xc_>-> 384        int  ref="+code=ctx" class="sref">ctx(pushsog_i
 35LI_ABORTEa href="+code=bu> 35LI_ABORTEant  ref="+code=ctx" class="sref">ctxreturnu id="L418" clas> 35ERRORode=ctx" class=> 35ERRORan>
/a>->ctx/*
5/*
pushsog_i
worame="L401"> 401woraan>
/class="comment">/*
tickes="sref">li_cil);
wora_s="sre="L392"> 392tic*">li_cil);
wora="L392"> 3925fs_log_vec      tickes="sref">li_cil);
"+coef="fs/xfs/xfs_log"+coef=ry" class="sre*">li_cil);
ef="fs/xfs/xfs_log_cil.c#tru id="L418" clas"lntaa> r_ofme="L383"> 383 r_ofan>
/a>-> 392li_cil);
"+coef="fs/xfs/xfs_log"+coef=ry"                            struct5xfs_lsn_t5/a>               lv->worame="L401"> 401woraan>
ref="+code=ctx" class="sref">ctx               push/og_i
 401
/a>-> 383
ref="+code=ctx" class="sref">ctx 394 5     59 id="xfs/xfs_log_cil.c#L454" id="L454"5ceckpoint5 href="fs/xfs/xfs_log_ci5.c#L359xc_ctfs/xfs_log_cil.c#L454" id="L454"5cand b) t5396" id="L396" class="li5e" na59span>
 397 5     59 lock
 "L37nass=epan esoaoften.75" clname="L427came= mlass="a409
         * correct order5w_ctx5>         * correct order5w href="f5e" name="L400"> 400 5     59="fs/xfs/xfs_log_cil.c#L482a*575" id="L4), bu485pan celatency75emlay usaga liline(a> m smmll class="comment">         * in log recove6>down_wri6e(&Kclass="comment">         *
 = cil60ass="line" name="L412"> 412/*
3=  394 6il" c60ss="l23" class="line/og_i
lassgran cme="L401"> 401lassgran can>
/class="comment">/*
 = tickes="sref">li_cil);
" name="L383"> 383
="sre*">li_cil);
+99"> 399
5h_seq96" id="L396" class="li6ass="60rrect   struct  407 6     60 class="sref"s="sref">li_cil);
"+coef="fs/xfs/xfs_log"+coef=ry" cl*">li_cil);
ef="fs/xfs/xfs_log_cil.c#tru id="L418" clas+99"> 399
 379     _ci3a href="+code=push_seq" class="sref">6="fs/xfs/6fs_log_cil.c#L408" id="L608" c60        400 6o be 60="fs/xfs/xfs_log_cil.c#L482a href="fs/T"line" wome="L427b= ">xc_7b=cauL459         * correct order6again lat6r.
 4775" _loepan59 4ass=is cost2e5">  class="comment">         * that we proce6f="fs/xfs6xfs_log_cil.c#L412" id="6412" 61ass="line" name="L412"> 412        if (list6empty(&pushASSERcode=ctx" class=ASSERcan>
/a>)
xc_79"> 379    lass">xc_">xc_cil_lock);
 418
ctxcil6>/*
(& 425         * pull all the 6"5h_seqout_skip;

 m lassgran c "L37n1" id=haveme="L427us483upgf="L426lass="comment">         * pull all the 6"lass="li6lass="line" name="L417">6417
         *
spin_un6ock(& 419
6a hre61="sref">tickeil->new_ctx;
; LOG_ass_SPACE_LIMIc">xc_>-> 399
 420 6     61lv" class="sref">lvctx6ctx < xc_current_sequf="+code=xc_cil_lock" class="sref">xc_cil_lock);
 404        6lass="sre6">out_skip;
->new_ctx;
seqme="L401"> 401seq"srefvecs; r    struct  424 6     624"> 444          a>->new_ctx;
seqme="L401"> 401seq"srefs="line" name="L464"> 464        ef="+code=push_seq" class="sref">6lsh_seqlv_nex id="L404" classs=ue>worame="L401"> 401wora">xc_>-> 399
 379     mp"L39379" class="line" nam>    worass=ue79"> 379   m>    worass=ue   s,ecil_lock);
worame="L401"> 401woraan>
ref="+code=ctx" class="sref">ctxitem-&gxfs/xfs_log_cil.c#L454" id="L454"6o="L417" 6e CIL. We don't need6the C62 class="sref">ctx->xc_cil_lock);
 418
/* check for a p6= /*
 =60;
clasgran cme="L401"> 401clasgran can>
/class="comment">/*
num_iove6s = 0;
li_cil);
" name="L383"> 383
="sre*">li_cil);
+99"> 399
;
seqme="L401"> 401seq"sre           "fs/xfs/6ist_empty(&xfs_log_item6    *6a href="+code=s="sref">li_cil);
"+coef="fs/xfs/xfs_log"+coef=ry" cl*">li_cil);
ef="fs/xfs/xfs_log_cil.c#tru id="L418" clas+99"> 399
 379     _ci3a href="+code=push_seq" class="sref">6t="L417" 6 class="sref">i;
n6='s o6e" name="L438"> 438 6     637ef">i &lil)
urrently6> = lisreturnef="+code=ctx" class="sref">ctx9fs/xfs/6code=xfs_log_item" class6"sref63span class="comment">/* check for a p6lass="sre6">list_del_init(&6;

/ass="line" nameref">seqme="L401"> 401seq"sreecil_lcil_lcass="line" nameref">seqme="L401"> 401seq"srefvecss="line" name="L464"> 464        /xfs/xfs_log_cil.c#L419" id="L419"6"sref">ct6->->worame="L401"> 401wora">xc_cil_lock);
worame="L401"> 401woraan>
ref="+code=ctx" class="sref">ctx->lv =6item-&ge="L425"> 425         * pull all the 6>="L417" 6>->
 4ass=is ">xc_7liloog_cil.c#Llreadyc1"> 42ss="li" name=""> 4lass="comment">         * pull all the 6>'s o6e" name="L448"> 448 6     64 to ensure
 405 neclass="comment">         *
num_6v++;
ticket = xc_cil_lock);
 404        6ref">ii &lil->xc_79"> 379    lass">xc_">xc_cil_lock);
 418
seqme="L401"> 401seq"srefvecss="line" name="L464"> 464        seqme="L401"> 401seq"srer    struct  += lv->>ctx->xc_cil_lock);
 418
6453lv_returnef="+code=ctx" class="sref">ctx 454 6     65ss="line" namxfs/xfs_log_cil.c#L454" id="L454"6="fs/xfs/6fs_log_cil.c#L455" id="L655" c65xc_ctfs/xfs_log_cil.c#L454" id="L454"6dlv =6xt and attach it to the 6IL. T65ef">push_seq <= new_ctx;
seqme="L401"> 401seq"srefs="line" name="L4ref">seqme="L401"> 401seq"sreef="+code=ctx" class="sref">ctxctx->xc_cil_lock);
 418
ticket =  401
/a>-> 399
INIT6LIST_HEAD(&INIT6LIST_HEAD(&6>
         * pull all the 6wlass="li6>
 428<483"> 483givenass="lil485"> 4a id="L483Item Llasclass="comment">         *
->
         * pull all the 6wlv =6e" name="L466"> 466 6     66span>
 405 format5"> 48tem, las9" e"na>emlay il
 class="lips_lous483"yan c28"> 4286"Ore r"> have id=" s_log_cs/xfs_log_cil.c#L4claa href="fs/xuon in6='s o6into the cil structure s6 that66mit
 428,"line" n426lass="comment">         * pull all the 6=ced. 428        3Lhroughlass="comment">         * pull all the 6=9fs/xfs/6eed context pointer.
/a>,"l"> 481n ="srefnd="L426"" id="ie="L428"> 4286lass="comment">         * pull all the 6f="fs/xfs6xfs_log_cil.c#L471" id="6471" 67g_cil.c#L411" id="L411" clas*lass="comment">         * pull all the 6fef">INIT6ref="+code=xc_current_se6uence67ass="line" name="L412"> 412 4L484" of operath"n if ( 473 6     67FI.  Hence
    cla() pleaL45="+errhref="+co hrefth"n if (
        s()class="comment">         *

         * pull all the 6ntext. We6can't just go straig6t to 67span>
 483me="L475"> 47Llreadycheld"ie=readsmlderhre"> 47ouelass="comment">         * correct order6n"fs/xfs/6hronise with previous an6 futu67 lock
   ,_returns w83"out5" eheld"ore rlassgran c /a>   s/" class="comment">         * correct order6n's o6are correctly ordered in6the l67mit
         *
    cla
    claan>
/class="comment">/*
lvs="sref">li_cil);
"+com
lv*">li_cil);
m379"> 379   mp"L390class="comment">/*
li_cil);
"emp9" id
lv*">li_cil);
t379"> 379   tp"L390class="comment">/*
;
lv*">li_cil);
"line"name="L392"> 392        /*
li_cil);
" name="L383"> 383
="sresref">lv*">li_cil);
+99"> 399
 379   mp"L39379" class="line" nam>+99"> 399

xfs/xfs_log_cil.c#L419" id="L419"6ylass="li6fs_log_cil.c#L488" id="L688" c687 class="sref"L4888888888888888888888ass="line" name" idflagd
tickes="sref">li_cil);
list_empss=
tic*">li_cil);
+99_ss="li
/* check for a p6s="sref">6fs_log_vec      i &lil-> 35TRANSsRELEASE_LOG_RES
               lv->ass="line" name" idflagd
 35LOG_REL_PERM_RESERV
               /*
 394 6     69ss="line" name="L474"> 474
emlay if (
)7oueside5"> 4ass=me="L475"> 456 397 6     69 lock
 4s w81n 9emlay l"> a=""> 428<5pan cespends/" if (
emlay re         *
6> 400 6     699"sref">ticket = 
/a>-> 379   tp"L39)xfs/xfs_log_cil.c#L419" id="L419"7>down_wri7e(&i &lil)
 = cil70ass="sref">lv->returnu id="L418" clasENOMEM
2=                /*
3=  394 7il" c70ss="line" name="L474"> 474 47ouerlassgran c /a>   xf  if ( = xc_cil_lock);
 399
 379     _ci3a hrL418" id="L418" class="line" name="L401"> 401        ctx5h_seq96" id="L396" class="li7ass="705ef">i &lil-> 392        ctx6h_seq" name="L397"> 397 7     70/xfs/xfs_log_cil.c#L4*">li_cil);
"line"name="L392"> 392         399
 379     _ci3a hr_ctx;
 406
ctx7h_seq ticket = 
/a>-> 399
 379   tp"L393" id="L463" class="t>ticket_alloc(ctx9fs/xfs/7f" name="L400"> 400 7o be 70span class="comment">/* check for a p7again lat7r.
i &lil-> 379   tp"L393" id="L463" class="t>ticket_alloc(uenc_re="srefvecs 0rf="+code=ctx" class="sref">ctxlist7empty(&lv_t =  399
 379     mp"L390" class="line" n8379"> 379   tp"L393" id="L463" class="t>ticket_alloc(ctxcil7>/*
(& 425 428        3f  if (out_skip;
i &lil)
xc_79"> 379    lass">xc_">xc_cil_lock);
 379   tp"L393" id="L463" class="t>_alloc(coderr    struct 7417ctx->xc_cil_lock);
 399
 379     _ci3a hr_ctx;
 418
spin_un7ock(&)
xc_cil_lock);
 379   tp"L393" id="L463" class="t>_alloc(code0class="comment">/*
 419
7a hre71try" class="sref">lis->ttttttttttttttttcil_lock);
 399
 379     _ci3a hrL418" id="L418" class="linxfs_log_cil.c#L465" id="Lid="L406" class="lin_       xfs_log_cil.c#L_       ="fs/xfs/xfs_log_cil.c#L419" id="L419"7"9fs/xfs/7e" name="L420"> 420 7     71lv" class="sref">lvctx->xc_cil_lock);
 399
 379     _ci3a hr_ctx;
 418
7out_skip;
push8379"> 379   tp"L393" id="L463" class="t>"line"name="L392"> 392"line"namea hrtru*">li_cil);
"line"name="L392"> 392        cil7e" name="L424"> 424 7     72 id="L434" class="line" name     o" id="
xc_>-> 379   mp"L390" class="line" n8379"> 379   tp"L393" id="L463" class="t>ticket_alloc(( =  399

/a>-> 379   tp"L39)xfs/xfs_log_cil.c#L419" id="L419"7og vector7 off the items in the CI7, and72span class="comment">/*
="L474"> 474 428<5ppi="L485"> 4ass, if (         *
         *
(a> be id=" beclas" clnrop5"> 4ass=me="L475"> 47b=cauL459         *
 updatehstmte"ie="L42pan"" id="ane=="srefn"L4m beclas""L4y golass="comment">         *
 = 0;
 nisk.cIf5 clname="L42, 481n "> 4ass=m5" id="L485"m rs_low83">us/anes/xfs_log_cil.c#L4claa href="fs/xuon in7> = 0;

/a> beclas" cg_cil.c#updated"ane=="srefees/xfs_log_cil.c#L4claa href="fs/xuon in7>sh_seq(&xfs_log_item7    *73span>
         *
i;
 438 7     737ef">i &l" id=
" id=an>
/a>-> 379   tp"L39,v*">li_cil);
"line"name="L392"> 392        urrently7> = 9fs/xfs/7code=xfs_log_item" class7"sref739"sref">ticket = lassgran cme="L401"> 401lassgran can>
/ock);
 399
list_del_init(&7ctxct7->xc_current_sequup_read
xc_cil_lock);
 399
 379     _ci3a hrL418" id="L418" class="line" name="L401"> 401        ctx->->lv =7->
 4ass=bas483onss="li" name="p         *
's o7e" name="L448"> 448 7     74 to ensure
 "L37n1" id=haveme="L427Llreadyc1"> 42ss="li" name= if ( donlyetime1we=is cotrigger3a "L37noero i=lass="comment">         * correct order7ref">i         *
 +=  412         *
7453
(a> determnamqifo" if ( 454 7     75ints so
         *

pass="line" name     sn>;
 =  392xc_ href="+code=list_empty" class="7d's o7ract the commit lsn of t7e seq757ef">i &ls="sref">li_cil);
" name="L383"> 383
="sre*">li_cil);
+99"> 399
ticket = ;
 406
ctxINIT7LIST_HEAD(&tickes="sref">li_cil);
"+coef="fs/xfs/xfs_log"+coef=ry" class="sre*">li_cil);
ef="fs/xfs/xfs_log_cil.c#tru id="L418" clas+99"> 399
 379     _ci3a hr (!INIT7LIST_HEAD(&lvs="sref">li_cil);
"+co
*">li_cil);
e"fs/xfs/xfs_log_cil.c#L3 (!push/    sn>;
lv">li_cil);
"line"name="L392"> 392        (/*
-> = 
/ass="line" namee" name="L406"> 406
 464        /xfs/xfs_log_cil.c#L419" id="L419"7wlv =7e" name="L466"> 466 7     76span class="comment">/*
="L474"> 474 seen1" id=405 fore="out5"> 4il.c#L457e="L47class="comment">         *
 4s class="lide= lass="sr, if ( nealow83">" eherKclass="comment">         *
INIT7ref="+code=xc_current_se7uence77class="sref">xc_current_sequ/og_i
clasgran cme="L401"> 401clasgran can>
/">li_cil);
+99"> 399
 406
 473 7     77span class="comment">/*
 474 a="" name=ni" name="st2     "l" class="comment">         *
 =7can't just go straig7t to 77span>
= if (
seq/hregremhead. Hame="b    <5pan cs class=os= a cwellclass="comment">         *
 406re=tar s="l: href="+code=list_empty" class="7f we get 7n EFI in one checkpoint 7nd th78a>;
xc_cil_lock);
 404        7 to log f7rces), we do not want th7 chec78class="sref">xc_current_sequclasscla_each_texr_79"> 379    lasscla_each_texr_an>
/">li_cil);
e"fs/xfs/xfs_log_cil.c#L3,ecil_lock);
 404      "l" ="fs c406" class="lin>     "l" me="L404"> 404<      "l" ="fsr    struct lv_il-> 406
 406
ctx 444                  7e="inueef="+code=push_seq" class="sref">7 ow done,7callbacks are attached t7 the 78" class="srefref">lv_il)
 392         444                  e="L474"> 474
 4d! Worreclas         *

=, 481n =tar 11 froman c2         *
lv 401xc_cil_lock);
 401);
 404        7s="sref">7fs_log_vec      i &lllllllllllllllllgohre406" class="linre=tar "L406"> 406re=tar s="lef="+code=push_seq" class="sref">7sto log f7/a>               lv->xfs/xfs_log_cil.c#L454" id="L454"7xfs_lsn_t7/a>               lv_il-> 406
 406
ctx 394 7     794"> 444                  7e="inueef="+code=push_seq" class="sref">7ceckpoint7 href="fs/xfs/xfs_log_ci7.c#L379" class="sref">lv_nex ="L425"> 425 444          ">li_cil);
"line"name="L392"> 392         392        7c.7e" name="L397"> 397 7     79 class="sref"xfs/xfs_log_cil.c#L454" id="L454"7xlass="li7= i &lxc_cil_lock);
 418
7>tickereturnu id="L418" clas"line"name="L392"> 392        7c"fs/xfs/7e" name="L400"> 400 7     799"srexfs/xfs_log_cil.c#L454" id="L454"8>down_wri8e(&ctx = cil80ass="line" name="L412"> 412 c if (         *
3=  394 8il" c80ints so
el" cin "> 4ass,r"> have hre"5" ilass="comment">         *
4=    xi" name="numberclass="comment">         *
5= 
         *
6=  397 8     80 lock
 be cmll d w83"lass="comment">         *
7= 
         *
8=  428   xprocess w81n decidl" cw_loga> format5in485"> 4" idclass="comment">         *
9=  400 8o be 80="fs/xfs/xfs_log_cil.c#L482a*  if (;
ctxxc_ href="+code=list_empty" class="8ref">list8empty(&li_cil);
"emp ref" id
li_cil);
+i379"> 379    ip="fsrf="+code=ctx" class="sref">ctxcil8>(&li_cil);
"+co
li_cil);
e"fs/xfs/xfs_log_cil.c#L3 (!out_skip;
/*
8417->xc_79"> 379    lass">xc_">xc_cil_lock);
 379    ip="fs379" class="line" namioef="fs/xfs/xfs_logmioef=="fsrrf="+code=ctx" class="sref">ctx(& 406fals=c#L3 (! 419
8a hre81"fs/xfs/xfs_log_cil.c#L420" id="L420"8"9fs/xfs/8e" name="L420"> 420 8     819"sref">ticket =  379    ip="fs379" class="line" namiom379"> 379    iom3="fs379" class="line" nam>+99"> 399

379" class="line" name_ci379"> 379     _ci3a hrL418" id="L418" class="linxfs_log_cil.c#L465" id="L (!8ctx < xine" name="L412"> 412 c if (out_skip;

 recL48c4 elass="comment">         *
cil8e" name="L424"> 424 8     82ints so
(differ#L45485"> lass="comment">         *

         *

-> 35LSN_CMPxfs_log_cil.c#L> 35LSN_CMPan>
/">li_cil);
+i379"> 379    ip="fs379" class="line" namioseqme="L401"> 401 406
ctx 406fals=c#L3 (!tickereturnu id="L418" clas="s="L406"> 406="s=c#L3 (!ctx
 = 0;
         * pull all the 8> = 0;

xfs_log_item8    *83ef">pass="line" name og_i
xc_ href="+code=list_empty" class="8t="L417" 8 class="sref">i;
li_cil);
" name="L383"> 383
="sre*">li_cil);
+99"> 399
ctx 438 8     837ef">   struct tickes="sref">li_cil);
listef="fs/xfs/xfs_log"+coef=ry" cl*">li_cil);
ef="fs/xfs/xfs_log_cil.c# (!9fs/xfs/8code=xfs_log_item" class8"sref839"sref">tickes="sref">li_cil);
"+co
li_cil);
e"fs/xfs/xfs_log_cil.c#L3 (!list_del_init(&8ctxct8->xc_current_sequef="fs/xfs/xfs_log_cil.c#tru id="L418" claskmem_zmlloc"fs/xfs/xfs_logkmem_zmlloc">xc_sizeof(*">li_cil);
ef="fs/xfs/xfs_log_cil.c#) c406" class="linKM_SLEEPxfs_log_cil.c#LKM_SLEEPl.c#|406" class="linKM_MAYFAIL_alloc(-> 444          returnu id="L418" clasENOMEM
->lv =8push_seq <= xc_sizeof(*">li_cil);
e"fs/xfs/xfs_log_cil.c#L3) c406" class="linKM_SLEEPxfs_log_cil.c#LKM_SLEEPl.c#|406" class="linKM_MAYFAIL_alloc(->)
 448 8     847href="+code=item" cl>)

/">li_cil);
ef="fs/xfs/xfs_log_cil.c#)xfs/xfs_log_cil.c#L419" id="L419"8"urrently8v++;
lisreturnu id="L418" clasENOMEM
 += tickexfs/xfs_log_cil.c#L454" id="L454"8ref">ictx += xc_current_sequINIT_WORK
xc_cil_lock);
woraxfs_log_cil.c#L465ref">wora="fs c406" class="lin/og_i
woraxfs_log_cil.c#L4og_i
woral.c#)xfs/xfs_log_cil.c#L419" id="L419"8snum_iove8lass="line" name="L453">8453pushINIT_LIST_HEAD
xc_cil_lock);
 418
 454 8     85 id="L434" class="line" nameINIT_LIST_HEAD
xc_cil_lock);
 404      "l" ="fs)xfs/xfs_log_cil.c#L419" id="L419"8s"fs/xfs/8fs_log_cil.c#L455" id="L855" c85xc_ctx = xc_cil_lock);
 418
 =8xt and attach it to the 8IL. T85ef">push_seq <= xc_cil_lock);
 401        ctxpush_seq <= xc_cil_lock);
 401ctx
ticket = xc_cil_lock);
 404<      "l" ="fsref="+code=ctx" class="sref">ctxticket = xc_cil_lock);
INIT8LIST_HEAD(& 406
(&xc_current_seque"fs/xfs/xfs_log_cil.c#L3id="L406" class="lin"f="fs/xfs/xfs_log_cil.c#tru id="L418" clasef="fs/xfs/xfs_log_cil.c# (!pushef="fs/xfs/xfs_log_cil.c#L418" id="L418" class="linxfs_log_cil.c#L465" id="Ltru id="L418" clase"fs/xfs/xfs_log_cil.c#L3 (!tru id="L418" clase"fs/xfs/xfs_log_cil.c#L3id="L406" class="line" name="L406"> 406
ctx-> =8e" name="L466"> 466 8     86ef">push_seq <=  383
tru id="L418" clas+99"> 399
ctx="L417" 8fs_log_cil.c#L467" id="L867" c866f">push_seq <=  399
 379     _ci3a hrtru id="L418" clasef="fs/xfs/xfs_log_cil.c# (!
/* check for a p8f="fs/xfs8xfs_log_cil.c#L471" id="8471" 87g_cilvoidclass="comment">/* check for a p8fs="sref"8ref="+code=xc_current_se8uence87oint w3" class="line/og_i
 379   /og_i
xc_ href="+code=list_empty" class="8class="li8e" name="L473"> 473 8     87xfs_log_cil.cs="sref">li_cil);
" name="L383"> 383
="sre*">li_cil);
+99"> 399
ctx = il-> 399
 379     _ci3a hrL418" id="L418" class="linxfs_log_cil.c#L465" id="Lr    struct  444          il-> 399
 379     _ci3a hrL418" id="L418" class="linxfs_log_cil.c#L465" id="L3" id="L463" class="ticket_alloc( <= 
/">li_cil);
c99"> 399
 379     _ci3a hrL418" id="L418" class="linxfs_log_cil.c#L465" id="L3" id="L463" class="ticket_alloc()

/">li_cil);
c99"> 399
 379     _ci3a hrL418" id="L418" class="linxfs_log_cil.c#L465" id="Lr (!tickexfs/xfs_log_cil.c#L454" id="L454"8f9fs/xfs/8fs_log_cil.c#L480" id="L880" c87span class="comment">/* check for a p8f we get 8n EFI in one checkpoint 8nd th88a>;

/ass="line" nameec_">xc_cil_lock);
 379    ip="fs379" clas9"> 399
 379     _ci3a hr_ctx;
 418
xc_current_sequclassref""fs/xfs/xfs_logkmem_ref"an>
/">li_cil);
c99"> 399
 379     _ci3a hrL418"a href="+code=list_empty" cla8nced.o"li8e" nae the checkpoint wi7h th878ain8 classfs_log_cil.c#L454" id="L454"8f9fs/="li7he c8mmit records of the7chec8784">88class="comment">/*
-&g8one,7call8acks are attached t7 the878" c8ass="s


Tlyetriginal LXR software byfirs4"comment"http://sourc"allge.net/proj(a75/lxr">LXR "l"uni9 ,(a> beexperi/xf al verseclasy4"comment"mailto:lxr@tacux.noci3xr@tacux.no/a> .
3xr.tacux.no kindly hosec4 sy4"comment"http://www.redpill-tacpro.nociRedpill Lacpro AS/a> ,(provider2panLacuxinue5" e_logFIscoper6lass hrervice hrif5" 1995.