linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (c) 2010 Red Hat, Inc. All Rights Reserved.

 */

​

#include "xfs.h"

#include "xfs_fs.h"

#include "xfs_format.h"

#include "xfs_log_format.h"

#include "xfs_shared.h"

#include "xfs_trans_resv.h"

#include "xfs_mount.h"

#include "xfs_error.h"

#include "xfs_alloc.h"

#include "xfs_extent_busy.h"

#include "xfs_discard.h"

#include "xfs_trans.h"

#include "xfs_trans_priv.h"

#include "xfs_log.h"

#include "xfs_log_priv.h"

#include "xfs_trace.h"

​

struct workqueue_struct *xfs_discard_wq;

​

/*

 * Allocate a new ticket. Failing to get a new ticket makes it really hard to

 * recover, so we don't allow failure here. Also, we allocate in a context that

 * we don't want to be issuing transactions from, so we need to tell the

 * allocation code this as well.

 *

 * We don't reserve any space for the ticket - we are going to steal whatever

 * space we require from transactions as they commit. To ensure we reserve all

 * the space required, we need to set the current reservation of the ticket to

 * zero so that we know to steal the initial transaction overhead from the

 * first transaction commit.

 */

static struct xlog_ticket *

xlog_cil_ticket_alloc(

    struct xlog *log)

{

    struct xlog_ticket *tic;

​

    tic = xlog_ticket_alloc(log, 0, 1, XFS_TRANSACTION, 0,

                KM_SLEEP|KM_NOFS);

​

    /*

     * set the current reservation to zero so we know to steal the basic

     * transaction overhead reservation from the first transaction commit.

     */

    tic->t_curr_res = 0;

    return tic;

}

​

/*

 * After the first stage of log recovery is done, we know where the head and

 * tail of the log are. We need this log initialisation done before we can

 * initialise the first CIL checkpoint context.

 *

 * Here we allocate a log ticket to track space usage during a CIL push.  This

 * ticket is passed to xlog_write() directly so that we don't slowly leak log

 * space by failing to account for space used by log headers and additional

 * region headers for split regions.

 */

void

xlog_cil_init_post_recovery(

    struct xlog *log)

{

    log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);

    log->l_cilp->xc_ctx->sequence = 1;

}

​

static inline int

xlog_cil_iovec_space(

    uint    niovecs)

{

    return round_up((sizeof(struct xfs_log_vec) +

                    niovecs * sizeof(struct xfs_log_iovec)),

            sizeof(uint64_t));

}

​

/*

 * Allocate or pin log vector buffers for CIL insertion.

 *

 * The CIL currently uses disposable buffers for copying a snapshot of the

 * modified items into the log during a push. The biggest problem with this is

 * the requirement to allocate the disposable buffer during the commit if:

 *  a) does not exist; or

 *  b) it is too small

 *

 * If we do this allocation within xlog_cil_insert_format_items(), it is done

 * under the xc_ctx_lock, which means that a CIL push cannot occur during

 * the memory allocation. This means that we have a potential deadlock situation