2019-05-31 11:09:56 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-01-16 19:50:04 +03:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-18 23:09:15 +04:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 19:50:04 +03:00
|
|
|
*/
|
|
|
|
|
|
2014-03-07 00:10:45 +04:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
2006-01-16 19:50:04 +03:00
|
|
|
#include <linux/sched.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
#include <linux/completion.h>
|
|
|
|
|
#include <linux/buffer_head.h>
|
2006-03-29 23:36:49 +04:00
|
|
|
#include <linux/kallsyms.h>
|
2009-01-12 13:43:39 +03:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-01-16 19:50:04 +03:00
|
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-28 01:23:27 +03:00
|
|
|
#include "incore.h"
|
2006-01-16 19:50:04 +03:00
|
|
|
#include "glock.h"
|
2012-12-14 16:52:14 +04:00
|
|
|
#include "inode.h"
|
2006-01-16 19:50:04 +03:00
|
|
|
#include "log.h"
|
|
|
|
|
#include "lops.h"
|
|
|
|
|
#include "meta_io.h"
|
|
|
|
|
#include "trans.h"
|
2006-02-28 01:23:27 +03:00
|
|
|
#include "util.h"
|
GFS2: Various gfs2_logd improvements
This patch contains various tweaks to how log flushes and active item writeback
work. gfs2_logd is now managed by a waitqueue, and gfs2_log_reseve now waits
for gfs2_logd to do the log flushing. Multiple functions were rewritten to
remove the need to call gfs2_log_lock(). Instead of using one test to see if
gfs2_logd had work to do, there are now seperate tests to check if there
are two many buffers in the incore log or if there are two many items on the
active items list.
This patch is a port of a patch Steve Whitehouse wrote about a year ago, with
some minor changes. Since gfs2_ail1_start always submits all the active items,
it no longer needs to keep track of the first ai submitted, so this has been
removed. In gfs2_log_reserve(), the order of the calls to
prepare_to_wait_exclusive() and wake_up() when firing off the logd thread has
been switched. If it called wake_up first there was a small window for a race,
where logd could run and return before gfs2_log_reserve was ready to get woken
up. If gfs2_logd ran, but did not free up enough blocks, gfs2_log_reserve()
would be left waiting for gfs2_logd to eventualy run because it timed out.
Finally, gt_logd_secs, which controls how long to wait before gfs2_logd times
out, and flushes the log, can now be set on mount with ar_commit.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2010-05-04 23:29:16 +04:00
|
|
|
#include "trace_gfs2.h"
|
2006-01-16 19:50:04 +03:00
|
|
|
|
2020-07-23 21:14:07 +03:00
|
|
|
static void gfs2_print_trans(struct gfs2_sbd *sdp, const struct gfs2_trans *tr)
|
|
|
|
|
{
|
|
|
|
|
fs_warn(sdp, "Transaction created at: %pSR\n", (void *)tr->tr_ip);
|
|
|
|
|
fs_warn(sdp, "blocks=%u revokes=%u reserved=%u touched=%u\n",
|
|
|
|
|
tr->tr_blocks, tr->tr_revokes, tr->tr_reserved,
|
|
|
|
|
test_bit(TR_TOUCHED, &tr->tr_flags));
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
fs_warn(sdp, "Buf %u/%u Databuf %u/%u Revoke %u\n",
|
2020-07-23 21:14:07 +03:00
|
|
|
tr->tr_num_buf_new, tr->tr_num_buf_rm,
|
|
|
|
|
tr->tr_num_databuf_new, tr->tr_num_databuf_rm,
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
tr->tr_num_revoke);
|
2020-07-23 21:14:07 +03:00
|
|
|
}
|
|
|
|
|
|
2021-01-29 18:45:33 +03:00
|
|
|
int __gfs2_trans_begin(struct gfs2_trans *tr, struct gfs2_sbd *sdp,
|
|
|
|
|
unsigned int blocks, unsigned int revokes,
|
|
|
|
|
unsigned long ip)
|
2006-01-16 19:50:04 +03:00
|
|
|
{
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
unsigned int extra_revokes;
|
|
|
|
|
|
2020-07-23 21:14:07 +03:00
|
|
|
if (current->journal_info) {
|
|
|
|
|
gfs2_print_trans(sdp, current->journal_info);
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
2006-03-29 23:36:49 +04:00
|
|
|
BUG_ON(blocks == 0 && revokes == 0);
|
2006-01-16 19:50:04 +03:00
|
|
|
|
2009-05-13 13:56:52 +04:00
|
|
|
if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
|
|
|
|
|
return -EROFS;
|
|
|
|
|
|
2021-01-29 18:45:33 +03:00
|
|
|
tr->tr_ip = ip;
|
2006-01-16 19:50:04 +03:00
|
|
|
tr->tr_blocks = blocks;
|
|
|
|
|
tr->tr_revokes = revokes;
|
gfs2: Rework the log space allocation logic
The current log space allocation logic is hard to understand or extend.
The principle it that when the log is flushed, we may or may not have a
transaction active that has space allocated in the log. To deal with
that, we set aside a magical number of blocks to be used in case we
don't have an active transaction. It isn't clear that the pool will
always be big enough. In addition, we can't return unused log space at
the end of a transaction, so the number of blocks allocated must exactly
match the number of blocks used.
Simplify this as follows:
* When transactions are allocated or merged, always reserve enough
blocks to flush the transaction (err on the safe side).
* In gfs2_log_flush, return any allocated blocks that haven't been used.
* Maintain a pool of spare blocks big enough to do one log flush, as
before.
* In gfs2_log_flush, when we have no active transaction, allocate a
suitable number of blocks. For that, use the spare pool when
called from logd, and leave the pool alone otherwise. This means
that when the log is almost full, logd will still be able to do one
more log flush, which will result in more log space becoming
available.
This will make the log space allocator code easier to work with in
the future.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-10 14:49:56 +03:00
|
|
|
tr->tr_reserved = GFS2_LOG_FLUSH_MIN_BLOCKS;
|
2020-12-06 16:04:36 +03:00
|
|
|
if (blocks) {
|
|
|
|
|
/*
|
|
|
|
|
* The reserved blocks are either used for data or metadata.
|
|
|
|
|
* We can have mixed data and metadata, each with its own log
|
|
|
|
|
* descriptor block; see calc_reserved().
|
|
|
|
|
*/
|
|
|
|
|
tr->tr_reserved += blocks + 1 + DIV_ROUND_UP(blocks - 1, databuf_limit(sdp));
|
|
|
|
|
}
|
2014-02-21 19:22:35 +04:00
|
|
|
INIT_LIST_HEAD(&tr->tr_databuf);
|
|
|
|
|
INIT_LIST_HEAD(&tr->tr_buf);
|
2020-08-21 16:50:34 +03:00
|
|
|
INIT_LIST_HEAD(&tr->tr_list);
|
2020-06-05 22:12:34 +03:00
|
|
|
INIT_LIST_HEAD(&tr->tr_ail1_list);
|
|
|
|
|
INIT_LIST_HEAD(&tr->tr_ail2_list);
|
2014-02-21 19:22:35 +04:00
|
|
|
|
2020-12-13 01:30:22 +03:00
|
|
|
if (gfs2_assert_warn(sdp, tr->tr_reserved <= sdp->sd_jdesc->jd_blocks))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-06-12 18:20:41 +04:00
|
|
|
sb_start_intwrite(sdp->sd_vfs);
|
2006-01-16 19:50:04 +03:00
|
|
|
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
/*
|
|
|
|
|
* Try the reservations under sd_log_flush_lock to prevent log flushes
|
|
|
|
|
* from creating inconsistencies between the number of allocated and
|
|
|
|
|
* reserved revokes. If that fails, do a full-block allocation outside
|
|
|
|
|
* of the lock to avoid stalling log flushes. Then, allot the
|
|
|
|
|
* appropriate number of blocks to revokes, use as many revokes locally
|
|
|
|
|
* as needed, and "release" the surplus into the revokes pool.
|
|
|
|
|
*/
|
2020-12-13 01:30:22 +03:00
|
|
|
|
|
|
|
|
down_read(&sdp->sd_log_flush_lock);
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
if (gfs2_log_try_reserve(sdp, tr, &extra_revokes))
|
|
|
|
|
goto reserved;
|
|
|
|
|
up_read(&sdp->sd_log_flush_lock);
|
|
|
|
|
gfs2_log_reserve(sdp, tr, &extra_revokes);
|
|
|
|
|
down_read(&sdp->sd_log_flush_lock);
|
|
|
|
|
|
|
|
|
|
reserved:
|
|
|
|
|
gfs2_log_release_revokes(sdp, extra_revokes);
|
2020-12-13 01:30:22 +03:00
|
|
|
if (unlikely(!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))) {
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
gfs2_log_release_revokes(sdp, tr->tr_revokes);
|
2020-12-13 01:30:22 +03:00
|
|
|
up_read(&sdp->sd_log_flush_lock);
|
2020-12-13 13:37:17 +03:00
|
|
|
gfs2_log_release(sdp, tr->tr_reserved);
|
2021-01-29 18:45:33 +03:00
|
|
|
sb_end_intwrite(sdp->sd_vfs);
|
2020-12-13 01:30:22 +03:00
|
|
|
return -EROFS;
|
2021-01-29 18:45:33 +03:00
|
|
|
}
|
2006-01-16 19:50:04 +03:00
|
|
|
|
2006-02-28 01:23:27 +03:00
|
|
|
current->journal_info = tr;
|
2006-01-16 19:50:04 +03:00
|
|
|
|
|
|
|
|
return 0;
|
2021-01-29 18:45:33 +03:00
|
|
|
}
|
2006-01-16 19:50:04 +03:00
|
|
|
|
2021-01-29 18:45:33 +03:00
|
|
|
int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
|
|
|
|
|
unsigned int revokes)
|
|
|
|
|
{
|
|
|
|
|
struct gfs2_trans *tr;
|
|
|
|
|
int error;
|
2006-01-16 19:50:04 +03:00
|
|
|
|
2021-01-29 18:45:33 +03:00
|
|
|
tr = kmem_cache_zalloc(gfs2_trans_cachep, GFP_NOFS);
|
|
|
|
|
if (!tr)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
error = __gfs2_trans_begin(tr, sdp, blocks, revokes, _RET_IP_);
|
|
|
|
|
if (error)
|
|
|
|
|
kmem_cache_free(gfs2_trans_cachep, tr);
|
2006-01-16 19:50:04 +03:00
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void gfs2_trans_end(struct gfs2_sbd *sdp)
|
|
|
|
|
{
|
2006-04-11 22:49:06 +04:00
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
2012-04-16 19:40:56 +04:00
|
|
|
s64 nbuf;
|
2014-11-14 05:42:04 +03:00
|
|
|
|
2006-02-28 01:23:27 +03:00
|
|
|
current->journal_info = NULL;
|
2006-01-16 19:50:04 +03:00
|
|
|
|
2017-01-25 20:50:47 +03:00
|
|
|
if (!test_bit(TR_TOUCHED, &tr->tr_flags)) {
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
gfs2_log_release_revokes(sdp, tr->tr_revokes);
|
2020-12-13 01:30:22 +03:00
|
|
|
up_read(&sdp->sd_log_flush_lock);
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
gfs2_log_release(sdp, tr->tr_reserved);
|
2021-01-29 18:45:33 +03:00
|
|
|
if (!test_bit(TR_ONSTACK, &tr->tr_flags))
|
2019-04-17 21:04:27 +03:00
|
|
|
gfs2_trans_free(sdp, tr);
|
2021-02-03 18:15:27 +03:00
|
|
|
sb_end_intwrite(sdp->sd_vfs);
|
2006-01-16 19:50:04 +03:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
gfs2_log_release_revokes(sdp, tr->tr_revokes - tr->tr_num_revoke);
|
|
|
|
|
|
2012-04-16 19:40:56 +04:00
|
|
|
nbuf = tr->tr_num_buf_new + tr->tr_num_databuf_new;
|
|
|
|
|
nbuf -= tr->tr_num_buf_rm;
|
|
|
|
|
nbuf -= tr->tr_num_databuf_rm;
|
|
|
|
|
|
2020-12-06 22:10:51 +03:00
|
|
|
if (gfs2_assert_withdraw(sdp, nbuf <= tr->tr_blocks) ||
|
|
|
|
|
gfs2_assert_withdraw(sdp, tr->tr_num_revoke <= tr->tr_revokes))
|
2018-10-03 16:47:36 +03:00
|
|
|
gfs2_print_trans(sdp, tr);
|
2006-01-16 19:50:04 +03:00
|
|
|
|
|
|
|
|
gfs2_log_commit(sdp, tr);
|
2021-01-29 18:45:33 +03:00
|
|
|
if (!test_bit(TR_ONSTACK, &tr->tr_flags) &&
|
|
|
|
|
!test_bit(TR_ATTACHED, &tr->tr_flags))
|
2019-04-17 21:04:27 +03:00
|
|
|
gfs2_trans_free(sdp, tr);
|
GFS2: replace gfs2_ail structure with gfs2_trans
In order to allow transactions and log flushes to happen at the same
time, gfs2 needs to move the transaction accounting and active items
list code into the gfs2_trans structure. As a first step toward this,
this patch removes the gfs2_ail structure, and handles the active items
list in the gfs_trans structure. This keeps gfs2 from allocating an ail
structure on log flushes, and gives us a struture that can later be used
to store the transaction accounting outside of the gfs2 superblock
structure.
With this patch, at the end of a transaction, gfs2 will add the
gfs2_trans structure to the superblock if there is not one already.
This structure now has the active items fields that were previously in
gfs2_ail. This is not necessary in the case where the transaction was
simply used to add revokes, since these are never written outside of the
journal, and thus, don't need an active items list.
Also, in order to make sure that the transaction structure is not
removed while it's still in use by gfs2_trans_end, unlocking the
sd_log_flush_lock has to happen slightly later in ending the
transaction.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-04-06 05:31:46 +04:00
|
|
|
up_read(&sdp->sd_log_flush_lock);
|
2006-01-16 19:50:04 +03:00
|
|
|
|
2017-11-28 00:05:09 +03:00
|
|
|
if (sdp->sd_vfs->s_flags & SB_SYNCHRONOUS)
|
2018-01-08 18:34:17 +03:00
|
|
|
gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
|
|
|
|
|
GFS2_LFC_TRANS_END);
|
2021-02-03 18:15:27 +03:00
|
|
|
sb_end_intwrite(sdp->sd_vfs);
|
2006-01-16 19:50:04 +03:00
|
|
|
}
|
|
|
|
|
|
2012-12-14 21:54:21 +04:00
|
|
|
static struct gfs2_bufdata *gfs2_alloc_bufdata(struct gfs2_glock *gl,
|
2018-11-16 23:18:32 +03:00
|
|
|
struct buffer_head *bh)
|
2012-12-14 21:54:21 +04:00
|
|
|
{
|
|
|
|
|
struct gfs2_bufdata *bd;
|
|
|
|
|
|
|
|
|
|
bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL);
|
|
|
|
|
bd->bd_bh = bh;
|
|
|
|
|
bd->bd_gl = gl;
|
|
|
|
|
INIT_LIST_HEAD(&bd->bd_list);
|
2021-02-25 19:11:09 +03:00
|
|
|
INIT_LIST_HEAD(&bd->bd_ail_st_list);
|
|
|
|
|
INIT_LIST_HEAD(&bd->bd_ail_gl_list);
|
2012-12-14 21:54:21 +04:00
|
|
|
bh->b_private = bd;
|
|
|
|
|
return bd;
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-16 19:50:04 +03:00
|
|
|
/**
|
2013-01-28 13:30:07 +04:00
|
|
|
* gfs2_trans_add_data - Add a databuf to the transaction.
|
|
|
|
|
* @gl: The inode glock associated with the buffer
|
|
|
|
|
* @bh: The buffer to add
|
2006-01-16 19:50:04 +03:00
|
|
|
*
|
2018-06-04 15:50:16 +03:00
|
|
|
* This is used in journaled data mode.
|
|
|
|
|
* We need to journal the data block in the same way as metadata in
|
|
|
|
|
* the functions above. The difference is that here we have a tag
|
|
|
|
|
* which is two __be64's being the block number (as per meta data)
|
|
|
|
|
* and a flag which says whether the data block needs escaping or
|
|
|
|
|
* not. This means we need a new log entry for each 251 or so data
|
|
|
|
|
* blocks, which isn't an enormous overhead but twice as much as
|
|
|
|
|
* for normal metadata blocks.
|
2006-01-16 19:50:04 +03:00
|
|
|
*/
|
2013-01-28 13:30:07 +04:00
|
|
|
void gfs2_trans_add_data(struct gfs2_glock *gl, struct buffer_head *bh)
|
2012-12-14 16:52:14 +04:00
|
|
|
{
|
|
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
2015-03-16 19:52:05 +03:00
|
|
|
struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
|
2013-01-28 13:30:07 +04:00
|
|
|
struct gfs2_bufdata *bd;
|
2012-12-14 16:52:14 +04:00
|
|
|
|
2012-11-07 10:38:06 +04:00
|
|
|
lock_buffer(bh);
|
2017-01-30 19:51:21 +03:00
|
|
|
if (buffer_pinned(bh)) {
|
|
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2012-11-07 10:38:06 +04:00
|
|
|
gfs2_log_lock(sdp);
|
2006-02-28 01:23:27 +03:00
|
|
|
bd = bh->b_private;
|
2012-12-14 21:54:21 +04:00
|
|
|
if (bd == NULL) {
|
2012-11-07 10:38:06 +04:00
|
|
|
gfs2_log_unlock(sdp);
|
|
|
|
|
unlock_buffer(bh);
|
2012-12-14 21:54:21 +04:00
|
|
|
if (bh->b_private == NULL)
|
2018-11-16 23:18:32 +03:00
|
|
|
bd = gfs2_alloc_bufdata(gl, bh);
|
2015-10-01 19:47:31 +03:00
|
|
|
else
|
|
|
|
|
bd = bh->b_private;
|
2012-11-07 10:38:06 +04:00
|
|
|
lock_buffer(bh);
|
|
|
|
|
gfs2_log_lock(sdp);
|
2006-01-16 19:50:04 +03:00
|
|
|
}
|
2012-12-14 21:54:21 +04:00
|
|
|
gfs2_assert(sdp, bd->bd_gl == gl);
|
2017-01-25 20:50:47 +03:00
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
2013-01-28 13:30:07 +04:00
|
|
|
if (list_empty(&bd->bd_list)) {
|
|
|
|
|
set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
|
|
|
|
|
set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
|
|
|
|
|
gfs2_pin(sdp, bd->bd_bh);
|
|
|
|
|
tr->tr_num_databuf_new++;
|
2014-02-21 19:22:35 +04:00
|
|
|
list_add_tail(&bd->bd_list, &tr->tr_databuf);
|
2013-01-28 13:30:07 +04:00
|
|
|
}
|
2012-11-07 10:38:06 +04:00
|
|
|
gfs2_log_unlock(sdp);
|
2017-01-30 19:51:21 +03:00
|
|
|
out:
|
2012-11-07 10:38:06 +04:00
|
|
|
unlock_buffer(bh);
|
2006-01-16 19:50:04 +03:00
|
|
|
}
|
|
|
|
|
|
2017-01-25 20:57:42 +03:00
|
|
|
void gfs2_trans_add_meta(struct gfs2_glock *gl, struct buffer_head *bh)
|
2012-12-14 16:36:02 +04:00
|
|
|
{
|
2017-01-25 20:57:42 +03:00
|
|
|
|
|
|
|
|
struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
|
|
|
|
|
struct gfs2_bufdata *bd;
|
2012-12-14 16:52:14 +04:00
|
|
|
struct gfs2_meta_header *mh;
|
2017-01-30 19:51:21 +03:00
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
2014-11-14 05:42:04 +03:00
|
|
|
enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
|
2012-12-14 16:52:14 +04:00
|
|
|
|
2017-01-25 20:57:42 +03:00
|
|
|
lock_buffer(bh);
|
2017-01-30 19:51:21 +03:00
|
|
|
if (buffer_pinned(bh)) {
|
|
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2017-01-25 20:57:42 +03:00
|
|
|
gfs2_log_lock(sdp);
|
|
|
|
|
bd = bh->b_private;
|
|
|
|
|
if (bd == NULL) {
|
|
|
|
|
gfs2_log_unlock(sdp);
|
|
|
|
|
unlock_buffer(bh);
|
|
|
|
|
lock_page(bh->b_page);
|
|
|
|
|
if (bh->b_private == NULL)
|
2018-11-16 23:18:32 +03:00
|
|
|
bd = gfs2_alloc_bufdata(gl, bh);
|
2017-01-25 20:57:42 +03:00
|
|
|
else
|
|
|
|
|
bd = bh->b_private;
|
|
|
|
|
unlock_page(bh->b_page);
|
|
|
|
|
lock_buffer(bh);
|
|
|
|
|
gfs2_log_lock(sdp);
|
|
|
|
|
}
|
|
|
|
|
gfs2_assert(sdp, bd->bd_gl == gl);
|
2017-01-25 20:50:47 +03:00
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
2012-12-14 16:52:14 +04:00
|
|
|
if (!list_empty(&bd->bd_list))
|
2017-01-25 20:57:42 +03:00
|
|
|
goto out_unlock;
|
2012-12-14 16:52:14 +04:00
|
|
|
set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
|
|
|
|
|
set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
|
|
|
|
|
mh = (struct gfs2_meta_header *)bd->bd_bh->b_data;
|
|
|
|
|
if (unlikely(mh->mh_magic != cpu_to_be32(GFS2_MAGIC))) {
|
2018-10-03 16:47:36 +03:00
|
|
|
fs_err(sdp, "Attempting to add uninitialised block to "
|
|
|
|
|
"journal (inplace block=%lld)\n",
|
2012-12-14 16:52:14 +04:00
|
|
|
(unsigned long long)bd->bd_bh->b_blocknr);
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
2014-11-14 05:42:04 +03:00
|
|
|
if (unlikely(state == SFS_FROZEN)) {
|
2018-10-03 16:47:36 +03:00
|
|
|
fs_info(sdp, "GFS2:adding buf while frozen\n");
|
2014-11-14 05:42:04 +03:00
|
|
|
gfs2_assert_withdraw(sdp, 0);
|
|
|
|
|
}
|
2019-11-13 22:58:30 +03:00
|
|
|
if (unlikely(gfs2_withdrawn(sdp))) {
|
|
|
|
|
fs_info(sdp, "GFS2:adding buf while withdrawn! 0x%llx\n",
|
|
|
|
|
(unsigned long long)bd->bd_bh->b_blocknr);
|
|
|
|
|
}
|
2012-12-14 16:52:14 +04:00
|
|
|
gfs2_pin(sdp, bd->bd_bh);
|
|
|
|
|
mh->__pad0 = cpu_to_be64(0);
|
|
|
|
|
mh->mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
|
2014-02-21 19:22:35 +04:00
|
|
|
list_add(&bd->bd_list, &tr->tr_buf);
|
2012-12-14 16:52:14 +04:00
|
|
|
tr->tr_num_buf_new++;
|
2017-01-25 20:57:42 +03:00
|
|
|
out_unlock:
|
2012-12-14 16:52:14 +04:00
|
|
|
gfs2_log_unlock(sdp);
|
2017-01-30 19:51:21 +03:00
|
|
|
out:
|
2012-12-14 16:52:14 +04:00
|
|
|
unlock_buffer(bh);
|
2012-12-14 16:36:02 +04:00
|
|
|
}
|
|
|
|
|
|
2007-09-03 14:01:33 +04:00
|
|
|
void gfs2_trans_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
|
2006-01-16 19:50:04 +03:00
|
|
|
{
|
2012-12-14 16:29:56 +04:00
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
|
|
|
|
|
2012-05-01 20:00:34 +04:00
|
|
|
BUG_ON(!list_empty(&bd->bd_list));
|
2013-06-14 20:38:29 +04:00
|
|
|
gfs2_add_revoke(sdp, bd);
|
2017-01-25 20:50:47 +03:00
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
2012-12-14 16:29:56 +04:00
|
|
|
tr->tr_num_revoke++;
|
2006-01-16 19:50:04 +03:00
|
|
|
}
|
|
|
|
|
|
2019-04-05 14:18:23 +03:00
|
|
|
void gfs2_trans_remove_revoke(struct gfs2_sbd *sdp, u64 blkno, unsigned int len)
|
2006-01-16 19:50:04 +03:00
|
|
|
{
|
2008-02-01 16:16:55 +03:00
|
|
|
struct gfs2_bufdata *bd, *tmp;
|
|
|
|
|
unsigned int n = len;
|
2006-01-16 19:50:04 +03:00
|
|
|
|
|
|
|
|
gfs2_log_lock(sdp);
|
2019-04-05 14:16:14 +03:00
|
|
|
list_for_each_entry_safe(bd, tmp, &sdp->sd_log_revokes, bd_list) {
|
2008-02-01 16:16:55 +03:00
|
|
|
if ((bd->bd_blkno >= blkno) && (bd->bd_blkno < (blkno + len))) {
|
2012-05-01 20:00:34 +04:00
|
|
|
list_del_init(&bd->bd_list);
|
2006-01-16 19:50:04 +03:00
|
|
|
gfs2_assert_withdraw(sdp, sdp->sd_log_num_revoke);
|
|
|
|
|
sdp->sd_log_num_revoke--;
|
2019-11-14 17:49:11 +03:00
|
|
|
if (bd->bd_gl)
|
|
|
|
|
gfs2_glock_remove_revoke(bd->bd_gl);
|
2008-02-01 16:16:55 +03:00
|
|
|
kmem_cache_free(gfs2_bufdata_cachep, bd);
|
gfs2: Per-revoke accounting in transactions
In the log, revokes are stored as a revoke descriptor (struct
gfs2_log_descriptor), followed by zero or more additional revoke blocks
(struct gfs2_meta_header). On filesystems with a blocksize of 4k, the
revoke descriptor contains up to 503 revokes, and the metadata blocks
contain up to 509 revokes each. We've so far been reserving space for
revokes in transactions in block granularity, so a lot more space than
necessary was being allocated and then released again.
This patch switches to assigning revokes to transactions individually
instead. Initially, space for the revoke descriptor is reserved and
handed out to transactions. When more revokes than that are reserved,
additional revoke blocks are added. When the log is flushed, the space
for the additional revoke blocks is released, but we keep the space for
the revoke descriptor block allocated.
Transactions may still reserve more revokes than they will actually need
in the end, but now we won't overshoot the target as much, and by only
returning the space for excess revokes at log flush time, we further
reduce the amount of contention between processes.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2020-12-17 18:14:30 +03:00
|
|
|
gfs2_log_release_revokes(sdp, 1);
|
2008-02-01 16:16:55 +03:00
|
|
|
if (--n == 0)
|
|
|
|
|
break;
|
2006-01-16 19:50:04 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
gfs2_log_unlock(sdp);
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-17 21:04:27 +03:00
|
|
|
void gfs2_trans_free(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
|
|
|
|
|
{
|
|
|
|
|
if (tr == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list));
|
|
|
|
|
gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list));
|
|
|
|
|
gfs2_assert_warn(sdp, list_empty(&tr->tr_databuf));
|
|
|
|
|
gfs2_assert_warn(sdp, list_empty(&tr->tr_buf));
|
|
|
|
|
kmem_cache_free(gfs2_trans_cachep, tr);
|
|
|
|
|
}
|
