2019-05-31 16:09:56 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2006-01-17 00:50:04 +08:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-19 03:09:15 +08:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-17 00:50:04 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef __LOG_DOT_H__
|
|
|
|
|
#define __LOG_DOT_H__
|
|
|
|
|
|
2006-09-05 22:39:21 +08:00
|
|
|
#include <linux/list.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
2011-04-18 21:18:09 +08:00
|
|
|
#include <linux/writeback.h>
|
2006-09-05 22:39:21 +08:00
|
|
|
#include "incore.h"
|
2018-06-04 20:50:16 +08:00
|
|
|
#include "inode.h"
|
2006-09-05 22:39:21 +08:00
|
|
|
|
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 19:49:56 +08:00
|
|
|
/*
|
|
|
|
|
* The minimum amount of log space required for a log flush is one block for
|
|
|
|
|
* revokes and one block for the log header. Log flushes other than
|
|
|
|
|
* GFS2_LOG_HEAD_FLUSH_NORMAL may write one or two more log headers.
|
|
|
|
|
*/
|
|
|
|
|
#define GFS2_LOG_FLUSH_MIN_BLOCKS 4
|
|
|
|
|
|
2006-01-17 00:50:04 +08:00
|
|
|
/**
|
|
|
|
|
* gfs2_log_lock - acquire the right to mess with the log manager
|
|
|
|
|
* @sdp: the filesystem
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static inline void gfs2_log_lock(struct gfs2_sbd *sdp)
|
2008-05-30 09:27:51 +08:00
|
|
|
__acquires(&sdp->sd_log_lock)
|
2006-01-17 00:50:04 +08:00
|
|
|
{
|
|
|
|
|
spin_lock(&sdp->sd_log_lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gfs2_log_unlock - release the right to mess with the log manager
|
|
|
|
|
* @sdp: the filesystem
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static inline void gfs2_log_unlock(struct gfs2_sbd *sdp)
|
2008-05-30 09:27:51 +08:00
|
|
|
__releases(&sdp->sd_log_lock)
|
2006-01-17 00:50:04 +08:00
|
|
|
{
|
|
|
|
|
spin_unlock(&sdp->sd_log_lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void gfs2_log_pointers_init(struct gfs2_sbd *sdp,
|
|
|
|
|
unsigned int value)
|
|
|
|
|
{
|
|
|
|
|
if (++value == sdp->sd_jdesc->jd_blocks) {
|
|
|
|
|
value = 0;
|
|
|
|
|
}
|
2020-12-19 14:15:17 +08:00
|
|
|
sdp->sd_log_tail = value;
|
|
|
|
|
sdp->sd_log_flush_tail = value;
|
|
|
|
|
sdp->sd_log_head = value;
|
2006-01-17 00:50:04 +08:00
|
|
|
}
|
|
|
|
|
|
2013-01-28 17:30:07 +08:00
|
|
|
static inline void gfs2_ordered_add_inode(struct gfs2_inode *ip)
|
|
|
|
|
{
|
2018-10-13 02:07:27 +08:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2013-01-28 17:30:07 +08:00
|
|
|
|
2018-10-13 02:07:27 +08:00
|
|
|
if (gfs2_is_jdata(ip) || !gfs2_is_ordered(sdp))
|
2018-06-04 20:50:16 +08:00
|
|
|
return;
|
|
|
|
|
|
2020-06-17 20:47:34 +08:00
|
|
|
if (list_empty(&ip->i_ordered)) {
|
2013-01-28 17:30:07 +08:00
|
|
|
spin_lock(&sdp->sd_ordered_lock);
|
2020-06-17 20:47:34 +08:00
|
|
|
if (list_empty(&ip->i_ordered))
|
2019-04-05 19:16:14 +08:00
|
|
|
list_add(&ip->i_ordered, &sdp->sd_log_ordered);
|
2013-01-28 17:30:07 +08:00
|
|
|
spin_unlock(&sdp->sd_ordered_lock);
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-12-13 22:10:51 +08:00
|
|
|
|
2023-10-10 00:49:31 +08:00
|
|
|
void gfs2_ordered_del_inode(struct gfs2_inode *ip);
|
|
|
|
|
unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct);
|
|
|
|
|
void gfs2_remove_from_ail(struct gfs2_bufdata *bd);
|
|
|
|
|
bool gfs2_log_is_empty(struct gfs2_sbd *sdp);
|
|
|
|
|
void gfs2_log_release_revokes(struct gfs2_sbd *sdp, unsigned int revokes);
|
|
|
|
|
void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks);
|
|
|
|
|
bool gfs2_log_try_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
|
|
|
|
|
unsigned int *extra_revokes);
|
|
|
|
|
void gfs2_log_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
|
|
|
|
|
unsigned int *extra_revokes);
|
|
|
|
|
void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
|
|
|
|
|
u64 seq, u32 tail, u32 lblock, u32 flags,
|
|
|
|
|
blk_opf_t op_flags);
|
|
|
|
|
void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
|
|
|
|
|
u32 type);
|
|
|
|
|
void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *trans);
|
|
|
|
|
void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc);
|
|
|
|
|
void log_flush_wait(struct gfs2_sbd *sdp);
|
2007-11-08 22:25:12 +08:00
|
|
|
|
2023-10-10 00:49:31 +08:00
|
|
|
int gfs2_logd(void *data);
|
|
|
|
|
void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd);
|
|
|
|
|
void gfs2_glock_remove_revoke(struct gfs2_glock *gl);
|
|
|
|
|
void gfs2_flush_revokes(struct gfs2_sbd *sdp);
|
|
|
|
|
void gfs2_ail_drain(struct gfs2_sbd *sdp);
|
2006-01-17 00:50:04 +08:00
|
|
|
|
|
|
|
|
#endif /* __LOG_DOT_H__ */
|
