2019-05-31 08:09:56 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-01-16 16:50:04 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-18 19:09:15 +00:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
2014-03-06 20:10:45 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2006-01-16 16:50:04 +00: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 19:36:49 +00:00
|
|
|
#include <linux/kallsyms.h>
|
2009-01-12 10:43:39 +00:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "incore.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "glock.h"
|
2012-12-14 12:52:14 +00:00
|
|
|
#include "inode.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "log.h"
|
|
|
|
#include "lops.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "trans.h"
|
2006-02-27 22:23:27 +00: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 19:29:16 +00:00
|
|
|
#include "trace_gfs2.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-29 19:36:49 +00:00
|
|
|
int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
|
|
|
|
unsigned int revokes)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
struct gfs2_trans *tr;
|
|
|
|
int error;
|
|
|
|
|
2006-03-29 19:36:49 +00:00
|
|
|
BUG_ON(current->journal_info);
|
|
|
|
BUG_ON(blocks == 0 && revokes == 0);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2009-05-13 09:56:52 +00:00
|
|
|
if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
|
|
|
|
return -EROFS;
|
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
tr = kzalloc(sizeof(struct gfs2_trans), GFP_NOFS);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!tr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-10-03 18:15:36 +00:00
|
|
|
tr->tr_ip = _RET_IP_;
|
2006-01-16 16:50:04 +00:00
|
|
|
tr->tr_blocks = blocks;
|
|
|
|
tr->tr_revokes = revokes;
|
|
|
|
tr->tr_reserved = 1;
|
2017-01-25 17:50:47 +00:00
|
|
|
set_bit(TR_ALLOCED, &tr->tr_flags);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (blocks)
|
2006-04-11 18:49:06 +00:00
|
|
|
tr->tr_reserved += 6 + blocks;
|
2006-01-16 16:50:04 +00:00
|
|
|
if (revokes)
|
|
|
|
tr->tr_reserved += gfs2_struct2blk(sdp, revokes,
|
2006-09-04 16:49:07 +00:00
|
|
|
sizeof(u64));
|
2014-02-21 15:22:35 +00:00
|
|
|
INIT_LIST_HEAD(&tr->tr_databuf);
|
|
|
|
INIT_LIST_HEAD(&tr->tr_buf);
|
|
|
|
|
2012-06-12 14:20:41 +00:00
|
|
|
sb_start_intwrite(sdp->sd_vfs);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
error = gfs2_log_reserve(sdp, tr->tr_reserved);
|
|
|
|
if (error)
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-02 03:26:55 +00:00
|
|
|
goto fail;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-02-27 22:23:27 +00:00
|
|
|
current->journal_info = tr;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-02 03:26:55 +00:00
|
|
|
fail:
|
2012-06-12 14:20:41 +00:00
|
|
|
sb_end_intwrite(sdp->sd_vfs);
|
2006-01-16 16:50:04 +00:00
|
|
|
kfree(tr);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2018-10-03 13:47:36 +00:00
|
|
|
static void gfs2_print_trans(struct gfs2_sbd *sdp, const struct gfs2_trans *tr)
|
2012-04-16 15:40:56 +00:00
|
|
|
{
|
2018-10-03 13:47:36 +00:00
|
|
|
fs_warn(sdp, "Transaction created at: %pSR\n", (void *)tr->tr_ip);
|
|
|
|
fs_warn(sdp, "blocks=%u revokes=%u reserved=%u touched=%u\n",
|
2017-01-25 17:50:47 +00:00
|
|
|
tr->tr_blocks, tr->tr_revokes, tr->tr_reserved,
|
|
|
|
test_bit(TR_TOUCHED, &tr->tr_flags));
|
2018-10-03 13:47:36 +00:00
|
|
|
fs_warn(sdp, "Buf %u/%u Databuf %u/%u Revoke %u/%u\n",
|
2014-03-06 20:10:45 +00:00
|
|
|
tr->tr_num_buf_new, tr->tr_num_buf_rm,
|
|
|
|
tr->tr_num_databuf_new, tr->tr_num_databuf_rm,
|
|
|
|
tr->tr_num_revoke, tr->tr_num_revoke_rm);
|
2012-04-16 15:40:56 +00:00
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
void gfs2_trans_end(struct gfs2_sbd *sdp)
|
|
|
|
{
|
2006-04-11 18:49:06 +00:00
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
2012-04-16 15:40:56 +00:00
|
|
|
s64 nbuf;
|
2017-01-25 17:50:47 +00:00
|
|
|
int alloced = test_bit(TR_ALLOCED, &tr->tr_flags);
|
2014-11-14 02:42:04 +00:00
|
|
|
|
2006-02-27 22:23:27 +00:00
|
|
|
current->journal_info = NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2017-01-25 17:50:47 +00:00
|
|
|
if (!test_bit(TR_TOUCHED, &tr->tr_flags)) {
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_log_release(sdp, tr->tr_reserved);
|
2014-11-14 02:42:04 +00:00
|
|
|
if (alloced) {
|
2009-02-05 10:12:38 +00:00
|
|
|
kfree(tr);
|
2014-11-14 02:42:04 +00:00
|
|
|
sb_end_intwrite(sdp->sd_vfs);
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-04-16 15:40:56 +00:00
|
|
|
nbuf = tr->tr_num_buf_new + tr->tr_num_databuf_new;
|
|
|
|
nbuf -= tr->tr_num_buf_rm;
|
|
|
|
nbuf -= tr->tr_num_databuf_rm;
|
|
|
|
|
|
|
|
if (gfs2_assert_withdraw(sdp, (nbuf <= tr->tr_blocks) &&
|
|
|
|
(tr->tr_num_revoke <= tr->tr_revokes)))
|
2018-10-03 13:47:36 +00:00
|
|
|
gfs2_print_trans(sdp, tr);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
gfs2_log_commit(sdp, tr);
|
2017-01-25 17:50:47 +00:00
|
|
|
if (alloced && !test_bit(TR_ATTACHED, &tr->tr_flags))
|
|
|
|
kfree(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 01:31:46 +00:00
|
|
|
up_read(&sdp->sd_log_flush_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2017-11-27 21:05:09 +00:00
|
|
|
if (sdp->sd_vfs->s_flags & SB_SYNCHRONOUS)
|
2018-01-08 15:34:17 +00:00
|
|
|
gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
|
|
|
|
GFS2_LFC_TRANS_END);
|
2014-11-14 02:42:04 +00:00
|
|
|
if (alloced)
|
|
|
|
sb_end_intwrite(sdp->sd_vfs);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2012-12-14 17:54:21 +00:00
|
|
|
static struct gfs2_bufdata *gfs2_alloc_bufdata(struct gfs2_glock *gl,
|
2018-11-16 20:18:32 +00:00
|
|
|
struct buffer_head *bh)
|
2012-12-14 17:54:21 +00: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);
|
|
|
|
bh->b_private = bd;
|
|
|
|
return bd;
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
2013-01-28 09:30:07 +00: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 16:50:04 +00:00
|
|
|
*
|
2018-06-04 12:50:16 +00: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 16:50:04 +00:00
|
|
|
*/
|
2013-01-28 09:30:07 +00:00
|
|
|
void gfs2_trans_add_data(struct gfs2_glock *gl, struct buffer_head *bh)
|
2012-12-14 12:52:14 +00:00
|
|
|
{
|
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
2015-03-16 16:52:05 +00:00
|
|
|
struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
|
2013-01-28 09:30:07 +00:00
|
|
|
struct gfs2_bufdata *bd;
|
2012-12-14 12:52:14 +00:00
|
|
|
|
2012-11-07 06:38:06 +00:00
|
|
|
lock_buffer(bh);
|
2017-01-30 16:51:21 +00:00
|
|
|
if (buffer_pinned(bh)) {
|
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
|
|
|
goto out;
|
|
|
|
}
|
2012-11-07 06:38:06 +00:00
|
|
|
gfs2_log_lock(sdp);
|
2006-02-27 22:23:27 +00:00
|
|
|
bd = bh->b_private;
|
2012-12-14 17:54:21 +00:00
|
|
|
if (bd == NULL) {
|
2012-11-07 06:38:06 +00:00
|
|
|
gfs2_log_unlock(sdp);
|
|
|
|
unlock_buffer(bh);
|
2012-12-14 17:54:21 +00:00
|
|
|
if (bh->b_private == NULL)
|
2018-11-16 20:18:32 +00:00
|
|
|
bd = gfs2_alloc_bufdata(gl, bh);
|
2015-10-01 16:47:31 +00:00
|
|
|
else
|
|
|
|
bd = bh->b_private;
|
2012-11-07 06:38:06 +00:00
|
|
|
lock_buffer(bh);
|
|
|
|
gfs2_log_lock(sdp);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2012-12-14 17:54:21 +00:00
|
|
|
gfs2_assert(sdp, bd->bd_gl == gl);
|
2017-01-25 17:50:47 +00:00
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
2013-01-28 09:30:07 +00: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 15:22:35 +00:00
|
|
|
list_add_tail(&bd->bd_list, &tr->tr_databuf);
|
2013-01-28 09:30:07 +00:00
|
|
|
}
|
2012-11-07 06:38:06 +00:00
|
|
|
gfs2_log_unlock(sdp);
|
2017-01-30 16:51:21 +00:00
|
|
|
out:
|
2012-11-07 06:38:06 +00:00
|
|
|
unlock_buffer(bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2017-01-25 17:57:42 +00:00
|
|
|
void gfs2_trans_add_meta(struct gfs2_glock *gl, struct buffer_head *bh)
|
2012-12-14 12:36:02 +00:00
|
|
|
{
|
2017-01-25 17:57:42 +00:00
|
|
|
|
|
|
|
struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
|
|
|
|
struct gfs2_bufdata *bd;
|
2012-12-14 12:52:14 +00:00
|
|
|
struct gfs2_meta_header *mh;
|
2017-01-30 16:51:21 +00:00
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
2014-11-14 02:42:04 +00:00
|
|
|
enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
|
2012-12-14 12:52:14 +00:00
|
|
|
|
2017-01-25 17:57:42 +00:00
|
|
|
lock_buffer(bh);
|
2017-01-30 16:51:21 +00:00
|
|
|
if (buffer_pinned(bh)) {
|
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-01-25 17:57:42 +00: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 20:18:32 +00:00
|
|
|
bd = gfs2_alloc_bufdata(gl, bh);
|
2017-01-25 17:57:42 +00: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 17:50:47 +00:00
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
2012-12-14 12:52:14 +00:00
|
|
|
if (!list_empty(&bd->bd_list))
|
2017-01-25 17:57:42 +00:00
|
|
|
goto out_unlock;
|
2012-12-14 12:52:14 +00: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 13:47:36 +00:00
|
|
|
fs_err(sdp, "Attempting to add uninitialised block to "
|
|
|
|
"journal (inplace block=%lld)\n",
|
2012-12-14 12:52:14 +00:00
|
|
|
(unsigned long long)bd->bd_bh->b_blocknr);
|
|
|
|
BUG();
|
|
|
|
}
|
2014-11-14 02:42:04 +00:00
|
|
|
if (unlikely(state == SFS_FROZEN)) {
|
2018-10-03 13:47:36 +00:00
|
|
|
fs_info(sdp, "GFS2:adding buf while frozen\n");
|
2014-11-14 02:42:04 +00:00
|
|
|
gfs2_assert_withdraw(sdp, 0);
|
|
|
|
}
|
2012-12-14 12:52:14 +00: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 15:22:35 +00:00
|
|
|
list_add(&bd->bd_list, &tr->tr_buf);
|
2012-12-14 12:52:14 +00:00
|
|
|
tr->tr_num_buf_new++;
|
2017-01-25 17:57:42 +00:00
|
|
|
out_unlock:
|
2012-12-14 12:52:14 +00:00
|
|
|
gfs2_log_unlock(sdp);
|
2017-01-30 16:51:21 +00:00
|
|
|
out:
|
2012-12-14 12:52:14 +00:00
|
|
|
unlock_buffer(bh);
|
2012-12-14 12:36:02 +00:00
|
|
|
}
|
|
|
|
|
2007-09-03 10:01:33 +00:00
|
|
|
void gfs2_trans_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2012-12-14 12:29:56 +00:00
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
|
|
|
|
2012-05-01 16:00:34 +00:00
|
|
|
BUG_ON(!list_empty(&bd->bd_list));
|
2013-06-14 16:38:29 +00:00
|
|
|
gfs2_add_revoke(sdp, bd);
|
2017-01-25 17:50:47 +00:00
|
|
|
set_bit(TR_TOUCHED, &tr->tr_flags);
|
2012-12-14 12:29:56 +00:00
|
|
|
tr->tr_num_revoke++;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2019-04-05 11:18:23 +00:00
|
|
|
void gfs2_trans_remove_revoke(struct gfs2_sbd *sdp, u64 blkno, unsigned int len)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2008-02-01 13:16:55 +00:00
|
|
|
struct gfs2_bufdata *bd, *tmp;
|
|
|
|
struct gfs2_trans *tr = current->journal_info;
|
|
|
|
unsigned int n = len;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
gfs2_log_lock(sdp);
|
2019-04-05 11:16:14 +00:00
|
|
|
list_for_each_entry_safe(bd, tmp, &sdp->sd_log_revokes, bd_list) {
|
2008-02-01 13:16:55 +00:00
|
|
|
if ((bd->bd_blkno >= blkno) && (bd->bd_blkno < (blkno + len))) {
|
2012-05-01 16:00:34 +00:00
|
|
|
list_del_init(&bd->bd_list);
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_assert_withdraw(sdp, sdp->sd_log_num_revoke);
|
|
|
|
sdp->sd_log_num_revoke--;
|
2008-02-01 13:16:55 +00:00
|
|
|
kmem_cache_free(gfs2_bufdata_cachep, bd);
|
|
|
|
tr->tr_num_revoke_rm++;
|
|
|
|
if (--n == 0)
|
|
|
|
break;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
gfs2_log_unlock(sdp);
|
|
|
|
}
|
|
|
|
|