2019-05-31 02:09:56 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-01-16 09:50:04 -07:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2008-01-28 10:13:02 -07:00
|
|
|
* Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
|
2006-01-16 09:50:04 -07:00
|
|
|
*/
|
|
|
|
|
2014-03-06 13:10:45 -07:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
2006-01-30 11:34:10 -07:00
|
|
|
#include <linux/fs.h>
|
2006-02-27 15:23:27 -07:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2008-03-10 17:17:47 -06:00
|
|
|
#include <linux/prefetch.h>
|
2009-02-09 02:25:01 -07:00
|
|
|
#include <linux/blkdev.h>
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
#include <linux/rbtree.h>
|
2012-10-31 04:37:10 -06:00
|
|
|
#include <linux/random.h>
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 15:23:27 -07:00
|
|
|
#include "incore.h"
|
2006-01-16 09:50:04 -07:00
|
|
|
#include "glock.h"
|
|
|
|
#include "glops.h"
|
|
|
|
#include "lops.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "quota.h"
|
|
|
|
#include "rgrp.h"
|
|
|
|
#include "super.h"
|
|
|
|
#include "trans.h"
|
2006-02-27 15:23:27 -07:00
|
|
|
#include "util.h"
|
[GFS2] flush the log if a transaction can't allocate space
This is a fix for bz #208514. When GFS2 frees up space, the freed blocks
aren't available for reuse until the resource group is successfully written
to the ondisk journal. So in rare cases, GFS2 operations will fail, saying
that the filesystem is out of space, when in reality, you are just waiting for
a log flush. For instance, on a 1Gig filesystem, if I continually write 10 Mb
to a file, and then truncate it, after a hundred interations, the write will
fail with -ENOSPC, even though the filesystem is just 1% full.
The attached patch calls a log flush in these cases. I tested this patch
fairly heavily to check if there were any locking issues that I missed, and
it seems to work just fine. Also, this patch only does the log flush if
get_local_rgrp makes a complete loop of resource groups without skipping
any do to locking issues. The code would be slightly simpler if it just always
did the log flush after the first failed pass, and you could only ever have
to go through the loop twice, instead of up to three times. However, I guessed
that failing to find a rg simply do to locking issues would be common enough
to skip the log flush in that case, but I'm not certain that this is the right
way to go. Either way, I don't suppose this code will be hit all that often.
Signed-off-by: Benjamin E. Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-03-23 14:51:56 -06:00
|
|
|
#include "log.h"
|
2007-06-08 03:05:33 -06:00
|
|
|
#include "inode.h"
|
2009-06-12 01:49:20 -06:00
|
|
|
#include "trace_gfs2.h"
|
2017-12-12 10:42:30 -07:00
|
|
|
#include "dir.h"
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2006-09-05 13:41:57 -06:00
|
|
|
#define BFITNOENT ((u32)~0)
|
2007-07-24 13:09:32 -06:00
|
|
|
#define NO_BLOCK ((u64)~0)
|
2006-05-18 11:52:39 -06:00
|
|
|
|
2008-03-10 17:17:47 -06:00
|
|
|
#if BITS_PER_LONG == 32
|
|
|
|
#define LBITMASK (0x55555555UL)
|
|
|
|
#define LBITSKIP55 (0x55555555UL)
|
|
|
|
#define LBITSKIP00 (0x00000000UL)
|
|
|
|
#else
|
|
|
|
#define LBITMASK (0x5555555555555555UL)
|
|
|
|
#define LBITSKIP55 (0x5555555555555555UL)
|
|
|
|
#define LBITSKIP00 (0x0000000000000000UL)
|
|
|
|
#endif
|
|
|
|
|
2006-05-18 11:52:39 -06:00
|
|
|
/*
|
|
|
|
* These routines are used by the resource group routines (rgrp.c)
|
|
|
|
* to keep track of block allocation. Each block is represented by two
|
2006-06-14 13:32:57 -06:00
|
|
|
* bits. So, each byte represents GFS2_NBBY (i.e. 4) blocks.
|
|
|
|
*
|
|
|
|
* 0 = Free
|
|
|
|
* 1 = Used (not metadata)
|
|
|
|
* 2 = Unlinked (still in use) inode
|
|
|
|
* 3 = Used (metadata)
|
2006-05-18 11:52:39 -06:00
|
|
|
*/
|
|
|
|
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
struct gfs2_extent {
|
|
|
|
struct gfs2_rbm rbm;
|
|
|
|
u32 len;
|
|
|
|
};
|
|
|
|
|
2006-05-18 11:52:39 -06:00
|
|
|
static const char valid_change[16] = {
|
|
|
|
/* current */
|
2006-06-14 13:32:57 -06:00
|
|
|
/* n */ 0, 1, 1, 1,
|
2006-05-18 11:52:39 -06:00
|
|
|
/* e */ 1, 0, 0, 0,
|
2006-06-14 13:32:57 -06:00
|
|
|
/* w */ 0, 0, 0, 1,
|
2006-05-18 11:52:39 -06:00
|
|
|
1, 0, 0, 0
|
|
|
|
};
|
|
|
|
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
|
2016-05-02 08:42:49 -06:00
|
|
|
const struct gfs2_inode *ip, bool nowrap);
|
2012-09-10 03:03:50 -06:00
|
|
|
|
|
|
|
|
2006-05-18 11:52:39 -06:00
|
|
|
/**
|
|
|
|
* gfs2_setbit - Set a bit in the bitmaps
|
2012-08-13 04:37:51 -06:00
|
|
|
* @rbm: The position of the bit to set
|
|
|
|
* @do_clone: Also set the clone bitmap, if it exists
|
2006-05-18 11:52:39 -06:00
|
|
|
* @new_state: the new state of the block
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-08-13 04:37:51 -06:00
|
|
|
static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
|
2012-04-26 10:44:35 -06:00
|
|
|
unsigned char new_state)
|
2006-05-18 11:52:39 -06:00
|
|
|
{
|
2008-02-06 03:11:15 -07:00
|
|
|
unsigned char *byte1, *byte2, *end, cur_state;
|
2013-09-17 11:12:15 -06:00
|
|
|
struct gfs2_bitmap *bi = rbm_bi(rbm);
|
2018-09-26 16:32:46 -06:00
|
|
|
unsigned int buflen = bi->bi_bytes;
|
2012-08-13 04:37:51 -06:00
|
|
|
const unsigned int bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
|
2006-05-18 11:52:39 -06:00
|
|
|
|
2013-09-17 11:12:15 -06:00
|
|
|
byte1 = bi->bi_bh->b_data + bi->bi_offset + (rbm->offset / GFS2_NBBY);
|
|
|
|
end = bi->bi_bh->b_data + bi->bi_offset + buflen;
|
2006-05-18 11:52:39 -06:00
|
|
|
|
2008-02-06 03:11:15 -07:00
|
|
|
BUG_ON(byte1 >= end);
|
2006-05-18 11:52:39 -06:00
|
|
|
|
2008-02-06 03:11:15 -07:00
|
|
|
cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
|
2006-05-18 11:52:39 -06:00
|
|
|
|
2008-02-06 03:11:15 -07:00
|
|
|
if (unlikely(!valid_change[new_state * 4 + cur_state])) {
|
2018-10-03 07:47:36 -06:00
|
|
|
struct gfs2_sbd *sdp = rbm->rgd->rd_sbd;
|
|
|
|
|
|
|
|
fs_warn(sdp, "buf_blk = 0x%x old_state=%d, new_state=%d\n",
|
2014-03-06 13:10:45 -07:00
|
|
|
rbm->offset, cur_state, new_state);
|
2018-10-03 07:47:36 -06:00
|
|
|
fs_warn(sdp, "rgrp=0x%llx bi_start=0x%x biblk: 0x%llx\n",
|
|
|
|
(unsigned long long)rbm->rgd->rd_addr, bi->bi_start,
|
|
|
|
(unsigned long long)bi->bi_bh->b_blocknr);
|
2018-09-26 16:32:46 -06:00
|
|
|
fs_warn(sdp, "bi_offset=0x%x bi_bytes=0x%x block=0x%llx\n",
|
|
|
|
bi->bi_offset, bi->bi_bytes,
|
2018-10-03 07:47:36 -06:00
|
|
|
(unsigned long long)gfs2_rbm_to_block(rbm));
|
2011-03-22 08:49:12 -06:00
|
|
|
dump_stack();
|
2012-08-13 04:37:51 -06:00
|
|
|
gfs2_consist_rgrpd(rbm->rgd);
|
2008-02-06 03:11:15 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
*byte1 ^= (cur_state ^ new_state) << bit;
|
|
|
|
|
2013-09-17 11:12:15 -06:00
|
|
|
if (do_clone && bi->bi_clone) {
|
|
|
|
byte2 = bi->bi_clone + bi->bi_offset + (rbm->offset / GFS2_NBBY);
|
2008-02-06 03:11:15 -07:00
|
|
|
cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
|
|
|
|
*byte2 ^= (cur_state ^ new_state) << bit;
|
|
|
|
}
|
2006-05-18 11:52:39 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_testbit - test a bit in the bitmaps
|
2012-08-13 04:14:57 -06:00
|
|
|
* @rbm: The bit to test
|
2018-08-07 09:07:00 -06:00
|
|
|
* @use_clone: If true, test the clone bitmap, not the official bitmap.
|
|
|
|
*
|
|
|
|
* Some callers like gfs2_unaligned_extlen need to test the clone bitmaps,
|
|
|
|
* not the "real" bitmaps, to avoid allocating recently freed blocks.
|
2006-05-18 11:52:39 -06:00
|
|
|
*
|
2012-08-13 04:14:57 -06:00
|
|
|
* Returns: The two bit block state of the requested bit
|
2006-05-18 11:52:39 -06:00
|
|
|
*/
|
|
|
|
|
2018-08-07 09:07:00 -06:00
|
|
|
static inline u8 gfs2_testbit(const struct gfs2_rbm *rbm, bool use_clone)
|
2006-05-18 11:52:39 -06:00
|
|
|
{
|
2013-09-17 11:12:15 -06:00
|
|
|
struct gfs2_bitmap *bi = rbm_bi(rbm);
|
2018-08-07 09:07:00 -06:00
|
|
|
const u8 *buffer;
|
2012-08-13 04:14:57 -06:00
|
|
|
const u8 *byte;
|
2006-05-18 11:52:39 -06:00
|
|
|
unsigned int bit;
|
|
|
|
|
2018-08-07 09:07:00 -06:00
|
|
|
if (use_clone && bi->bi_clone)
|
|
|
|
buffer = bi->bi_clone;
|
|
|
|
else
|
|
|
|
buffer = bi->bi_bh->b_data;
|
|
|
|
buffer += bi->bi_offset;
|
2012-08-13 04:14:57 -06:00
|
|
|
byte = buffer + (rbm->offset / GFS2_NBBY);
|
|
|
|
bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
|
2006-05-18 11:52:39 -06:00
|
|
|
|
2012-08-13 04:14:57 -06:00
|
|
|
return (*byte >> bit) & GFS2_BIT_MASK;
|
2006-05-18 11:52:39 -06:00
|
|
|
}
|
|
|
|
|
2009-02-17 07:13:35 -07:00
|
|
|
/**
|
|
|
|
* gfs2_bit_search
|
|
|
|
* @ptr: Pointer to bitmap data
|
|
|
|
* @mask: Mask to use (normally 0x55555.... but adjusted for search start)
|
|
|
|
* @state: The state we are searching for
|
|
|
|
*
|
|
|
|
* We xor the bitmap data with a patter which is the bitwise opposite
|
|
|
|
* of what we are looking for, this gives rise to a pattern of ones
|
|
|
|
* wherever there is a match. Since we have two bits per entry, we
|
|
|
|
* take this pattern, shift it down by one place and then and it with
|
|
|
|
* the original. All the even bit positions (0,2,4, etc) then represent
|
|
|
|
* successful matches, so we mask with 0x55555..... to remove the unwanted
|
|
|
|
* odd bit positions.
|
|
|
|
*
|
|
|
|
* This allows searching of a whole u64 at once (32 blocks) with a
|
|
|
|
* single test (on 64 bit arches).
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
|
|
|
|
{
|
|
|
|
u64 tmp;
|
|
|
|
static const u64 search[] = {
|
2009-02-20 18:11:42 -07:00
|
|
|
[0] = 0xffffffffffffffffULL,
|
|
|
|
[1] = 0xaaaaaaaaaaaaaaaaULL,
|
|
|
|
[2] = 0x5555555555555555ULL,
|
|
|
|
[3] = 0x0000000000000000ULL,
|
2009-02-17 07:13:35 -07:00
|
|
|
};
|
|
|
|
tmp = le64_to_cpu(*ptr) ^ search[state];
|
|
|
|
tmp &= (tmp >> 1);
|
|
|
|
tmp &= mask;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2012-07-19 06:12:40 -06:00
|
|
|
/**
|
|
|
|
* rs_cmp - multi-block reservation range compare
|
|
|
|
* @blk: absolute file system block number of the new reservation
|
|
|
|
* @len: number of blocks in the new reservation
|
|
|
|
* @rs: existing reservation to compare against
|
|
|
|
*
|
|
|
|
* returns: 1 if the block range is beyond the reach of the reservation
|
|
|
|
* -1 if the block range is before the start of the reservation
|
|
|
|
* 0 if the block range overlaps with the reservation
|
|
|
|
*/
|
|
|
|
static inline int rs_cmp(u64 blk, u32 len, struct gfs2_blkreserv *rs)
|
|
|
|
{
|
2012-07-31 08:21:20 -06:00
|
|
|
u64 startblk = gfs2_rbm_to_block(&rs->rs_rbm);
|
2012-07-19 06:12:40 -06:00
|
|
|
|
|
|
|
if (blk >= startblk + rs->rs_free)
|
|
|
|
return 1;
|
|
|
|
if (blk + len - 1 < startblk)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-05-18 11:52:39 -06:00
|
|
|
/**
|
|
|
|
* gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
|
|
|
|
* a block in a given allocation state.
|
2012-04-11 11:03:52 -06:00
|
|
|
* @buf: the buffer that holds the bitmaps
|
2009-02-17 07:13:35 -07:00
|
|
|
* @len: the length (in bytes) of the buffer
|
2006-05-18 11:52:39 -06:00
|
|
|
* @goal: start search at this block's bit-pair (within @buffer)
|
2009-02-17 07:13:35 -07:00
|
|
|
* @state: GFS2_BLKST_XXX the state of the block we're looking for.
|
2006-05-18 11:52:39 -06:00
|
|
|
*
|
|
|
|
* Scope of @goal and returned block number is only within this bitmap buffer,
|
|
|
|
* not entire rgrp or filesystem. @buffer will be offset from the actual
|
2009-02-17 07:13:35 -07:00
|
|
|
* beginning of a bitmap block buffer, skipping any header structures, but
|
|
|
|
* headers are always a multiple of 64 bits long so that the buffer is
|
|
|
|
* always aligned to a 64 bit boundary.
|
|
|
|
*
|
|
|
|
* The size of the buffer is in bytes, but is it assumed that it is
|
2009-07-16 09:13:03 -06:00
|
|
|
* always ok to read a complete multiple of 64 bits at the end
|
2009-02-17 07:13:35 -07:00
|
|
|
* of the block in case the end is no aligned to a natural boundary.
|
2006-05-18 11:52:39 -06:00
|
|
|
*
|
|
|
|
* Return: the block number (bitmap buffer scope) that was found
|
|
|
|
*/
|
|
|
|
|
2009-02-20 18:12:05 -07:00
|
|
|
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
|
|
|
|
u32 goal, u8 state)
|
2006-05-18 11:52:39 -06:00
|
|
|
{
|
2009-02-17 07:13:35 -07:00
|
|
|
u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
|
|
|
|
const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
|
|
|
|
const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
|
|
|
|
u64 tmp;
|
2009-02-20 18:11:42 -07:00
|
|
|
u64 mask = 0x5555555555555555ULL;
|
2009-02-17 07:13:35 -07:00
|
|
|
u32 bit;
|
|
|
|
|
|
|
|
/* Mask off bits we don't care about at the start of the search */
|
|
|
|
mask <<= spoint;
|
|
|
|
tmp = gfs2_bit_search(ptr, mask, state);
|
|
|
|
ptr++;
|
|
|
|
while(tmp == 0 && ptr < end) {
|
2009-02-20 18:11:42 -07:00
|
|
|
tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
|
2009-02-17 07:13:35 -07:00
|
|
|
ptr++;
|
2008-03-10 17:17:47 -06:00
|
|
|
}
|
2009-02-17 07:13:35 -07:00
|
|
|
/* Mask off any bits which are more than len bytes from the start */
|
|
|
|
if (ptr == end && (len & (sizeof(u64) - 1)))
|
|
|
|
tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
|
|
|
|
/* Didn't find anything, so return */
|
|
|
|
if (tmp == 0)
|
|
|
|
return BFITNOENT;
|
|
|
|
ptr--;
|
2009-04-23 01:54:02 -06:00
|
|
|
bit = __ffs64(tmp);
|
2009-02-17 07:13:35 -07:00
|
|
|
bit /= 2; /* two bits per entry in the bitmap */
|
|
|
|
return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
|
2006-05-18 11:52:39 -06:00
|
|
|
}
|
|
|
|
|
2012-09-10 03:03:50 -06:00
|
|
|
/**
|
|
|
|
* gfs2_rbm_from_block - Set the rbm based upon rgd and block number
|
|
|
|
* @rbm: The rbm with rgd already set correctly
|
|
|
|
* @block: The block number (filesystem relative)
|
|
|
|
*
|
|
|
|
* This sets the bi and offset members of an rbm based on a
|
|
|
|
* resource group and a filesystem relative block number. The
|
|
|
|
* resource group must be set in the rbm on entry, the bi and
|
|
|
|
* offset members will be set by this function.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, or an error code
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block)
|
|
|
|
{
|
2018-10-11 11:35:50 -06:00
|
|
|
if (!rgrp_contains_block(rbm->rgd, block))
|
2012-09-10 03:03:50 -06:00
|
|
|
return -E2BIG;
|
2013-09-17 11:12:15 -06:00
|
|
|
rbm->bii = 0;
|
2018-10-11 11:35:50 -06:00
|
|
|
rbm->offset = block - rbm->rgd->rd_data0;
|
2012-10-19 06:32:51 -06:00
|
|
|
/* Check if the block is within the first block */
|
2013-09-17 11:12:15 -06:00
|
|
|
if (rbm->offset < rbm_bi(rbm)->bi_blocks)
|
2012-10-19 06:32:51 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Adjust for the size diff between gfs2_meta_header and gfs2_rgrp */
|
|
|
|
rbm->offset += (sizeof(struct gfs2_rgrp) -
|
|
|
|
sizeof(struct gfs2_meta_header)) * GFS2_NBBY;
|
2013-09-17 11:12:15 -06:00
|
|
|
rbm->bii = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
|
|
|
|
rbm->offset -= rbm->bii * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
|
2012-09-10 03:03:50 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-17 11:14:35 -06:00
|
|
|
/**
|
|
|
|
* gfs2_rbm_incr - increment an rbm structure
|
|
|
|
* @rbm: The rbm with rgd already set correctly
|
|
|
|
*
|
|
|
|
* This function takes an existing rbm structure and increments it to the next
|
|
|
|
* viable block offset.
|
|
|
|
*
|
|
|
|
* Returns: If incrementing the offset would cause the rbm to go past the
|
|
|
|
* end of the rgrp, true is returned, otherwise false.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static bool gfs2_rbm_incr(struct gfs2_rbm *rbm)
|
|
|
|
{
|
|
|
|
if (rbm->offset + 1 < rbm_bi(rbm)->bi_blocks) { /* in the same bitmap */
|
|
|
|
rbm->offset++;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (rbm->bii == rbm->rgd->rd_length - 1) /* at the last bitmap */
|
|
|
|
return true;
|
|
|
|
|
|
|
|
rbm->offset = 0;
|
|
|
|
rbm->bii++;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-09-10 03:03:50 -06:00
|
|
|
/**
|
|
|
|
* gfs2_unaligned_extlen - Look for free blocks which are not byte aligned
|
|
|
|
* @rbm: Position to search (value/result)
|
|
|
|
* @n_unaligned: Number of unaligned blocks to check
|
|
|
|
* @len: Decremented for each block found (terminate on zero)
|
|
|
|
*
|
|
|
|
* Returns: true if a non-free block is encountered
|
|
|
|
*/
|
|
|
|
|
|
|
|
static bool gfs2_unaligned_extlen(struct gfs2_rbm *rbm, u32 n_unaligned, u32 *len)
|
|
|
|
{
|
|
|
|
u32 n;
|
|
|
|
u8 res;
|
|
|
|
|
|
|
|
for (n = 0; n < n_unaligned; n++) {
|
2018-08-07 09:07:00 -06:00
|
|
|
res = gfs2_testbit(rbm, true);
|
2012-09-10 03:03:50 -06:00
|
|
|
if (res != GFS2_BLKST_FREE)
|
|
|
|
return true;
|
|
|
|
(*len)--;
|
|
|
|
if (*len == 0)
|
|
|
|
return true;
|
2013-09-17 11:14:35 -06:00
|
|
|
if (gfs2_rbm_incr(rbm))
|
2012-09-10 03:03:50 -06:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_free_extlen - Return extent length of free blocks
|
2014-07-02 14:05:27 -06:00
|
|
|
* @rrbm: Starting position
|
2012-09-10 03:03:50 -06:00
|
|
|
* @len: Max length to check
|
|
|
|
*
|
|
|
|
* Starting at the block specified by the rbm, see how many free blocks
|
|
|
|
* there are, not reading more than len blocks ahead. This can be done
|
|
|
|
* using memchr_inv when the blocks are byte aligned, but has to be done
|
|
|
|
* on a block by block basis in case of unaligned blocks. Also this
|
|
|
|
* function can cope with bitmap boundaries (although it must stop on
|
|
|
|
* a resource group boundary)
|
|
|
|
*
|
|
|
|
* Returns: Number of free blocks in the extent
|
|
|
|
*/
|
|
|
|
|
|
|
|
static u32 gfs2_free_extlen(const struct gfs2_rbm *rrbm, u32 len)
|
|
|
|
{
|
|
|
|
struct gfs2_rbm rbm = *rrbm;
|
|
|
|
u32 n_unaligned = rbm.offset & 3;
|
|
|
|
u32 size = len;
|
|
|
|
u32 bytes;
|
|
|
|
u32 chunk_size;
|
|
|
|
u8 *ptr, *start, *end;
|
|
|
|
u64 block;
|
2013-09-17 11:12:15 -06:00
|
|
|
struct gfs2_bitmap *bi;
|
2012-09-10 03:03:50 -06:00
|
|
|
|
|
|
|
if (n_unaligned &&
|
|
|
|
gfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
|
|
|
|
goto out;
|
|
|
|
|
2012-09-12 07:40:31 -06:00
|
|
|
n_unaligned = len & 3;
|
2012-09-10 03:03:50 -06:00
|
|
|
/* Start is now byte aligned */
|
|
|
|
while (len > 3) {
|
2013-09-17 11:12:15 -06:00
|
|
|
bi = rbm_bi(&rbm);
|
|
|
|
start = bi->bi_bh->b_data;
|
|
|
|
if (bi->bi_clone)
|
|
|
|
start = bi->bi_clone;
|
|
|
|
start += bi->bi_offset;
|
2018-09-26 16:32:46 -06:00
|
|
|
end = start + bi->bi_bytes;
|
2012-09-10 03:03:50 -06:00
|
|
|
BUG_ON(rbm.offset & 3);
|
|
|
|
start += (rbm.offset / GFS2_NBBY);
|
|
|
|
bytes = min_t(u32, len / GFS2_NBBY, (end - start));
|
|
|
|
ptr = memchr_inv(start, 0, bytes);
|
|
|
|
chunk_size = ((ptr == NULL) ? bytes : (ptr - start));
|
|
|
|
chunk_size *= GFS2_NBBY;
|
|
|
|
BUG_ON(len < chunk_size);
|
|
|
|
len -= chunk_size;
|
|
|
|
block = gfs2_rbm_to_block(&rbm);
|
2012-12-20 11:21:07 -07:00
|
|
|
if (gfs2_rbm_from_block(&rbm, block + chunk_size)) {
|
|
|
|
n_unaligned = 0;
|
2012-09-10 03:03:50 -06:00
|
|
|
break;
|
2012-12-20 11:21:07 -07:00
|
|
|
}
|
|
|
|
if (ptr) {
|
|
|
|
n_unaligned = 3;
|
|
|
|
break;
|
|
|
|
}
|
2012-09-10 03:03:50 -06:00
|
|
|
n_unaligned = len & 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Deal with any bits left over at the end */
|
|
|
|
if (n_unaligned)
|
|
|
|
gfs2_unaligned_extlen(&rbm, n_unaligned, &len);
|
|
|
|
out:
|
|
|
|
return size - len;
|
|
|
|
}
|
|
|
|
|
2006-05-18 11:52:39 -06:00
|
|
|
/**
|
|
|
|
* gfs2_bitcount - count the number of bits in a certain state
|
2012-04-11 11:03:52 -06:00
|
|
|
* @rgd: the resource group descriptor
|
2006-05-18 11:52:39 -06:00
|
|
|
* @buffer: the buffer that holds the bitmaps
|
|
|
|
* @buflen: the length (in bytes) of the buffer
|
|
|
|
* @state: the state of the block we're looking for
|
|
|
|
*
|
|
|
|
* Returns: The number of bits
|
|
|
|
*/
|
|
|
|
|
2008-01-29 06:30:20 -07:00
|
|
|
static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
|
|
|
|
unsigned int buflen, u8 state)
|
2006-05-18 11:52:39 -06:00
|
|
|
{
|
2008-01-29 06:30:20 -07:00
|
|
|
const u8 *byte = buffer;
|
|
|
|
const u8 *end = buffer + buflen;
|
|
|
|
const u8 state1 = state << 2;
|
|
|
|
const u8 state2 = state << 4;
|
|
|
|
const u8 state3 = state << 6;
|
2006-09-04 10:49:07 -06:00
|
|
|
u32 count = 0;
|
2006-05-18 11:52:39 -06:00
|
|
|
|
|
|
|
for (; byte < end; byte++) {
|
|
|
|
if (((*byte) & 0x03) == state)
|
|
|
|
count++;
|
|
|
|
if (((*byte) & 0x0C) == state1)
|
|
|
|
count++;
|
|
|
|
if (((*byte) & 0x30) == state2)
|
|
|
|
count++;
|
|
|
|
if (((*byte) & 0xC0) == state3)
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
|
|
|
* gfs2_rgrp_verify - Verify that a resource group is consistent
|
|
|
|
* @rgd: the rgrp
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
struct gfs2_bitmap *bi = NULL;
|
2007-06-01 07:11:58 -06:00
|
|
|
u32 length = rgd->rd_length;
|
2006-09-04 10:49:07 -06:00
|
|
|
u32 count[4], tmp;
|
2006-01-16 09:50:04 -07:00
|
|
|
int buf, x;
|
|
|
|
|
2006-09-04 10:49:07 -06:00
|
|
|
memset(count, 0, 4 * sizeof(u32));
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
/* Count # blocks in each of 4 possible allocation states */
|
|
|
|
for (buf = 0; buf < length; buf++) {
|
|
|
|
bi = rgd->rd_bits + buf;
|
|
|
|
for (x = 0; x < 4; x++)
|
|
|
|
count[x] += gfs2_bitcount(rgd,
|
|
|
|
bi->bi_bh->b_data +
|
|
|
|
bi->bi_offset,
|
2018-09-26 16:32:46 -06:00
|
|
|
bi->bi_bytes, x);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2008-11-04 03:25:13 -07:00
|
|
|
if (count[0] != rgd->rd_free) {
|
2006-01-16 09:50:04 -07:00
|
|
|
if (gfs2_consist_rgrpd(rgd))
|
|
|
|
fs_err(sdp, "free data mismatch: %u != %u\n",
|
2008-11-04 03:25:13 -07:00
|
|
|
count[0], rgd->rd_free);
|
2006-01-16 09:50:04 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 03:32:57 -07:00
|
|
|
tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
|
2009-07-10 17:13:26 -06:00
|
|
|
if (count[1] != tmp) {
|
2006-01-16 09:50:04 -07:00
|
|
|
if (gfs2_consist_rgrpd(rgd))
|
|
|
|
fs_err(sdp, "used data mismatch: %u != %u\n",
|
|
|
|
count[1], tmp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-10 17:13:26 -06:00
|
|
|
if (count[2] + count[3] != rgd->rd_dinodes) {
|
2006-01-16 09:50:04 -07:00
|
|
|
if (gfs2_consist_rgrpd(rgd))
|
2006-06-14 13:32:57 -06:00
|
|
|
fs_err(sdp, "used metadata mismatch: %u != %u\n",
|
2009-07-10 17:13:26 -06:00
|
|
|
count[2] + count[3], rgd->rd_dinodes);
|
2006-01-16 09:50:04 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_blk2rgrpd - Find resource group for a given data/meta block number
|
|
|
|
* @sdp: The GFS2 superblock
|
2012-04-11 11:03:52 -06:00
|
|
|
* @blk: The data block number
|
|
|
|
* @exact: True if this needs to be an exact match
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
2017-12-22 05:13:07 -07:00
|
|
|
* The @exact argument should be set to true by most callers. The exception
|
|
|
|
* is when we need to match blocks which are not represented by the rgrp
|
|
|
|
* bitmap, but which are part of the rgrp (i.e. padding blocks) which are
|
|
|
|
* there for alignment purposes. Another way of looking at it is that @exact
|
|
|
|
* matches only valid data/metadata blocks, but with @exact false, it will
|
|
|
|
* match any block within the extent of the rgrp.
|
|
|
|
*
|
2006-01-16 09:50:04 -07:00
|
|
|
* Returns: The resource group, or NULL if not found
|
|
|
|
*/
|
|
|
|
|
2012-02-08 05:58:32 -07:00
|
|
|
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2012-02-08 05:58:32 -07:00
|
|
|
struct rb_node *n, *next;
|
2011-09-08 03:21:13 -06:00
|
|
|
struct gfs2_rgrpd *cur;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
spin_lock(&sdp->sd_rindex_spin);
|
2012-02-08 05:58:32 -07:00
|
|
|
n = sdp->sd_rindex_tree.rb_node;
|
|
|
|
while (n) {
|
|
|
|
cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
|
|
|
|
next = NULL;
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
if (blk < cur->rd_addr)
|
2012-02-08 05:58:32 -07:00
|
|
|
next = n->rb_left;
|
2011-09-08 03:21:13 -06:00
|
|
|
else if (blk >= cur->rd_data0 + cur->rd_data)
|
2012-02-08 05:58:32 -07:00
|
|
|
next = n->rb_right;
|
|
|
|
if (next == NULL) {
|
2006-01-16 09:50:04 -07:00
|
|
|
spin_unlock(&sdp->sd_rindex_spin);
|
2012-02-08 05:58:32 -07:00
|
|
|
if (exact) {
|
|
|
|
if (blk < cur->rd_addr)
|
|
|
|
return NULL;
|
|
|
|
if (blk >= cur->rd_data0 + cur->rd_data)
|
|
|
|
return NULL;
|
|
|
|
}
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
return cur;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
2012-02-08 05:58:32 -07:00
|
|
|
n = next;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
spin_unlock(&sdp->sd_rindex_spin);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
|
|
|
|
* @sdp: The GFS2 superblock
|
|
|
|
*
|
|
|
|
* Returns: The first rgrp in the filesystem
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
|
|
|
|
{
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
const struct rb_node *n;
|
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
spin_lock(&sdp->sd_rindex_spin);
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
n = rb_first(&sdp->sd_rindex_tree);
|
|
|
|
rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
|
2011-08-31 09:38:29 -06:00
|
|
|
spin_unlock(&sdp->sd_rindex_spin);
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
|
|
|
|
return rgd;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_rgrpd_get_next - get the next RG
|
2012-04-11 11:03:52 -06:00
|
|
|
* @rgd: the resource group descriptor
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
|
|
|
* Returns: The next rgrp
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
const struct rb_node *n;
|
|
|
|
|
|
|
|
spin_lock(&sdp->sd_rindex_spin);
|
|
|
|
n = rb_next(&rgd->rd_node);
|
|
|
|
if (n == NULL)
|
|
|
|
n = rb_first(&sdp->sd_rindex_tree);
|
|
|
|
|
|
|
|
if (unlikely(&rgd->rd_node == n)) {
|
|
|
|
spin_unlock(&sdp->sd_rindex_spin);
|
2006-01-16 09:50:04 -07:00
|
|
|
return NULL;
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
}
|
|
|
|
rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
|
|
|
|
spin_unlock(&sdp->sd_rindex_spin);
|
|
|
|
return rgd;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2014-09-18 20:40:28 -06:00
|
|
|
void check_and_update_goal(struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
|
|
|
if (!ip->i_goal || gfs2_blk2rgrpd(sdp, ip->i_goal, 1) == NULL)
|
|
|
|
ip->i_goal = ip->i_no_addr;
|
|
|
|
}
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
void gfs2_free_clones(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
int x;
|
|
|
|
|
|
|
|
for (x = 0; x < rgd->rd_length; x++) {
|
|
|
|
struct gfs2_bitmap *bi = rgd->rd_bits + x;
|
|
|
|
kfree(bi->bi_clone);
|
|
|
|
bi->bi_clone = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-06 04:17:59 -06:00
|
|
|
/**
|
2015-10-26 09:40:28 -06:00
|
|
|
* gfs2_rsqa_alloc - make sure we have a reservation assigned to the inode
|
|
|
|
* plus a quota allocations data structure, if necessary
|
2012-06-06 04:17:59 -06:00
|
|
|
* @ip: the inode for this reservation
|
|
|
|
*/
|
2015-10-26 09:40:28 -06:00
|
|
|
int gfs2_rsqa_alloc(struct gfs2_inode *ip)
|
2012-06-06 04:17:59 -06:00
|
|
|
{
|
2015-07-16 07:28:04 -06:00
|
|
|
return gfs2_qa_alloc(ip);
|
2012-06-06 04:17:59 -06:00
|
|
|
}
|
|
|
|
|
2019-05-09 08:21:48 -06:00
|
|
|
static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs,
|
|
|
|
const char *fs_id_buf)
|
2012-07-19 06:12:40 -06:00
|
|
|
{
|
2018-06-13 07:52:47 -06:00
|
|
|
struct gfs2_inode *ip = container_of(rs, struct gfs2_inode, i_res);
|
|
|
|
|
2019-05-09 08:21:48 -06:00
|
|
|
gfs2_print_dbg(seq, "%s B: n:%llu s:%llu b:%u f:%u\n", fs_id_buf,
|
2018-06-13 07:52:47 -06:00
|
|
|
(unsigned long long)ip->i_no_addr,
|
2012-08-23 08:37:59 -06:00
|
|
|
(unsigned long long)gfs2_rbm_to_block(&rs->rs_rbm),
|
2012-07-31 08:21:20 -06:00
|
|
|
rs->rs_rbm.offset, rs->rs_free);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
|
2012-06-06 04:17:59 -06:00
|
|
|
/**
|
2012-07-19 06:12:40 -06:00
|
|
|
* __rs_deltree - remove a multi-block reservation from the rgd tree
|
|
|
|
* @rs: The reservation to remove
|
|
|
|
*
|
|
|
|
*/
|
2013-03-13 08:26:38 -06:00
|
|
|
static void __rs_deltree(struct gfs2_blkreserv *rs)
|
2012-07-19 06:12:40 -06:00
|
|
|
{
|
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
|
|
|
|
if (!gfs2_rs_active(rs))
|
|
|
|
return;
|
|
|
|
|
2012-07-31 08:21:20 -06:00
|
|
|
rgd = rs->rs_rbm.rgd;
|
2012-08-23 08:37:59 -06:00
|
|
|
trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
|
2012-07-31 08:21:20 -06:00
|
|
|
rb_erase(&rs->rs_node, &rgd->rd_rstree);
|
2012-08-05 23:04:08 -06:00
|
|
|
RB_CLEAR_NODE(&rs->rs_node);
|
2012-07-19 06:12:40 -06:00
|
|
|
|
|
|
|
if (rs->rs_free) {
|
2018-09-27 08:30:25 -06:00
|
|
|
u64 last_block = gfs2_rbm_to_block(&rs->rs_rbm) +
|
|
|
|
rs->rs_free - 1;
|
|
|
|
struct gfs2_rbm last_rbm = { .rgd = rs->rs_rbm.rgd, };
|
|
|
|
struct gfs2_bitmap *start, *last;
|
2013-09-17 11:12:15 -06:00
|
|
|
|
2013-03-13 08:26:38 -06:00
|
|
|
/* return reserved blocks to the rgrp */
|
2012-07-31 08:21:20 -06:00
|
|
|
BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
|
|
|
|
rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
|
2013-11-25 04:16:25 -07:00
|
|
|
/* The rgrp extent failure point is likely not to increase;
|
|
|
|
it will only do so if the freed blocks are somehow
|
|
|
|
contiguous with a span of free blocks that follows. Still,
|
|
|
|
it will force the number to be recalculated later. */
|
|
|
|
rgd->rd_extfail_pt += rs->rs_free;
|
2012-07-19 06:12:40 -06:00
|
|
|
rs->rs_free = 0;
|
2018-09-27 08:30:25 -06:00
|
|
|
if (gfs2_rbm_from_block(&last_rbm, last_block))
|
|
|
|
return;
|
|
|
|
start = rbm_bi(&rs->rs_rbm);
|
|
|
|
last = rbm_bi(&last_rbm);
|
|
|
|
do
|
|
|
|
clear_bit(GBF_FULL, &start->bi_flags);
|
|
|
|
while (start++ != last);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
|
|
|
|
* @rs: The reservation to remove
|
|
|
|
*
|
|
|
|
*/
|
2013-03-13 08:26:38 -06:00
|
|
|
void gfs2_rs_deltree(struct gfs2_blkreserv *rs)
|
2012-07-19 06:12:40 -06:00
|
|
|
{
|
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
|
2012-07-31 08:21:20 -06:00
|
|
|
rgd = rs->rs_rbm.rgd;
|
|
|
|
if (rgd) {
|
|
|
|
spin_lock(&rgd->rd_rsspin);
|
2013-03-13 08:26:38 -06:00
|
|
|
__rs_deltree(rs);
|
2016-07-06 09:36:43 -06:00
|
|
|
BUG_ON(rs->rs_free);
|
2012-07-31 08:21:20 -06:00
|
|
|
spin_unlock(&rgd->rd_rsspin);
|
|
|
|
}
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-10-26 09:40:28 -06:00
|
|
|
* gfs2_rsqa_delete - delete a multi-block reservation and quota allocation
|
2012-06-06 04:17:59 -06:00
|
|
|
* @ip: The inode for this reservation
|
2013-09-27 05:49:33 -06:00
|
|
|
* @wcount: The inode's write count, or NULL
|
2012-06-06 04:17:59 -06:00
|
|
|
*
|
|
|
|
*/
|
2015-10-26 09:40:28 -06:00
|
|
|
void gfs2_rsqa_delete(struct gfs2_inode *ip, atomic_t *wcount)
|
2012-06-06 04:17:59 -06:00
|
|
|
{
|
|
|
|
down_write(&ip->i_rw_mutex);
|
2016-07-06 09:36:43 -06:00
|
|
|
if ((wcount == NULL) || (atomic_read(wcount) <= 1))
|
2015-07-16 07:28:04 -06:00
|
|
|
gfs2_rs_deltree(&ip->i_res);
|
2012-06-06 04:17:59 -06:00
|
|
|
up_write(&ip->i_rw_mutex);
|
2015-07-16 07:28:04 -06:00
|
|
|
gfs2_qa_delete(ip, wcount);
|
2012-06-06 04:17:59 -06:00
|
|
|
}
|
|
|
|
|
2012-07-19 06:12:40 -06:00
|
|
|
/**
|
|
|
|
* return_all_reservations - return all reserved blocks back to the rgrp.
|
|
|
|
* @rgd: the rgrp that needs its space back
|
|
|
|
*
|
|
|
|
* We previously reserved a bunch of blocks for allocation. Now we need to
|
|
|
|
* give them back. This leave the reservation structures in tact, but removes
|
|
|
|
* all of their corresponding "no-fly zones".
|
|
|
|
*/
|
|
|
|
static void return_all_reservations(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
struct rb_node *n;
|
|
|
|
struct gfs2_blkreserv *rs;
|
|
|
|
|
|
|
|
spin_lock(&rgd->rd_rsspin);
|
|
|
|
while ((n = rb_first(&rgd->rd_rstree))) {
|
|
|
|
rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
|
2013-03-13 08:26:38 -06:00
|
|
|
__rs_deltree(rs);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
spin_unlock(&rgd->rd_rsspin);
|
|
|
|
}
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
struct rb_node *n;
|
2006-01-16 09:50:04 -07:00
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
struct gfs2_glock *gl;
|
|
|
|
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
while ((n = rb_first(&sdp->sd_rindex_tree))) {
|
|
|
|
rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
|
2006-01-16 09:50:04 -07:00
|
|
|
gl = rgd->rd_gl;
|
|
|
|
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
rb_erase(n, &sdp->sd_rindex_tree);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
if (gl) {
|
2017-08-30 06:46:24 -06:00
|
|
|
glock_clear_object(gl, rgd);
|
2018-11-05 15:57:24 -07:00
|
|
|
gfs2_rgrp_brelse(rgd);
|
2006-01-16 09:50:04 -07:00
|
|
|
gfs2_glock_put(gl);
|
|
|
|
}
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
gfs2_free_clones(rgd);
|
2006-01-16 09:50:04 -07:00
|
|
|
kfree(rgd->rd_bits);
|
GFS2: don't set rgrp gl_object until it's inserted into rgrp tree
Before this patch, function read_rindex_entry would set a rgrp
glock's gl_object pointer to itself before inserting the rgrp into
the rgrp rbtree. The problem is: if another process was also reading
the rgrp in, and had already inserted its newly created rgrp, then
the second call to read_rindex_entry would overwrite that value,
then return a bad return code to the caller. Later, other functions
would reference the now-freed rgrp memory by way of gl_object.
In some cases, that could result in gfs2_rgrp_brelse being called
twice for the same rgrp: once for the failed attempt and once for
the "real" rgrp release. Eventually the kernel would panic.
There are also a number of other things that could go wrong when
a kernel module is accessing freed storage. For example, this could
result in rgrp corruption because the fake rgrp would point to a
fake bitmap in memory too, causing gfs2_inplace_reserve to search
some random memory for free blocks, and find some, since we were
never setting rgd->rd_bits to NULL before freeing it.
This patch fixes the problem by not setting gl_object until we
have successfully inserted the rgrp into the rbtree. Also, it sets
rd_bits to NULL as it frees them, which will ensure any accidental
access to the wrong rgrp will result in a kernel panic rather than
file system corruption, which is preferred.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2016-06-09 13:24:07 -06:00
|
|
|
rgd->rd_bits = NULL;
|
2012-07-19 06:12:40 -06:00
|
|
|
return_all_reservations(rgd);
|
2008-01-28 16:20:26 -07:00
|
|
|
kmem_cache_free(gfs2_rgrpd_cachep, rgd);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-01 07:11:58 -06:00
|
|
|
static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
2018-10-03 07:47:36 -06:00
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
|
|
|
|
fs_info(sdp, "ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
|
|
|
|
fs_info(sdp, "ri_length = %u\n", rgd->rd_length);
|
|
|
|
fs_info(sdp, "ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
|
|
|
|
fs_info(sdp, "ri_data = %u\n", rgd->rd_data);
|
|
|
|
fs_info(sdp, "ri_bitbytes = %u\n", rgd->rd_bitbytes);
|
2007-06-01 07:11:58 -06:00
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
|
|
|
* gfs2_compute_bitstructs - Compute the bitmap sizes
|
|
|
|
* @rgd: The resource group descriptor
|
|
|
|
*
|
|
|
|
* Calculates bitmap descriptors, one for each block that contains bitmap data
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int compute_bitstructs(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
struct gfs2_bitmap *bi;
|
2007-06-01 07:11:58 -06:00
|
|
|
u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
|
2006-09-04 10:49:07 -06:00
|
|
|
u32 bytes_left, bytes;
|
2006-01-16 09:50:04 -07:00
|
|
|
int x;
|
|
|
|
|
2006-06-14 13:32:57 -06:00
|
|
|
if (!length)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-07-27 12:29:00 -06:00
|
|
|
rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
|
2006-01-16 09:50:04 -07:00
|
|
|
if (!rgd->rd_bits)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-06-01 07:11:58 -06:00
|
|
|
bytes_left = rgd->rd_bitbytes;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
for (x = 0; x < length; x++) {
|
|
|
|
bi = rgd->rd_bits + x;
|
|
|
|
|
2009-05-21 05:23:12 -06:00
|
|
|
bi->bi_flags = 0;
|
2006-01-16 09:50:04 -07:00
|
|
|
/* small rgrp; bitmap stored completely in header block */
|
|
|
|
if (length == 1) {
|
|
|
|
bytes = bytes_left;
|
|
|
|
bi->bi_offset = sizeof(struct gfs2_rgrp);
|
|
|
|
bi->bi_start = 0;
|
2018-09-26 16:32:46 -06:00
|
|
|
bi->bi_bytes = bytes;
|
2013-09-11 12:44:02 -06:00
|
|
|
bi->bi_blocks = bytes * GFS2_NBBY;
|
2006-01-16 09:50:04 -07:00
|
|
|
/* header block */
|
|
|
|
} else if (x == 0) {
|
|
|
|
bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
|
|
|
|
bi->bi_offset = sizeof(struct gfs2_rgrp);
|
|
|
|
bi->bi_start = 0;
|
2018-09-26 16:32:46 -06:00
|
|
|
bi->bi_bytes = bytes;
|
2013-09-11 12:44:02 -06:00
|
|
|
bi->bi_blocks = bytes * GFS2_NBBY;
|
2006-01-16 09:50:04 -07:00
|
|
|
/* last block */
|
|
|
|
} else if (x + 1 == length) {
|
|
|
|
bytes = bytes_left;
|
|
|
|
bi->bi_offset = sizeof(struct gfs2_meta_header);
|
2007-06-01 07:11:58 -06:00
|
|
|
bi->bi_start = rgd->rd_bitbytes - bytes_left;
|
2018-09-26 16:32:46 -06:00
|
|
|
bi->bi_bytes = bytes;
|
2013-09-11 12:44:02 -06:00
|
|
|
bi->bi_blocks = bytes * GFS2_NBBY;
|
2006-01-16 09:50:04 -07:00
|
|
|
/* other blocks */
|
|
|
|
} else {
|
2006-02-27 10:00:42 -07:00
|
|
|
bytes = sdp->sd_sb.sb_bsize -
|
|
|
|
sizeof(struct gfs2_meta_header);
|
2006-01-16 09:50:04 -07:00
|
|
|
bi->bi_offset = sizeof(struct gfs2_meta_header);
|
2007-06-01 07:11:58 -06:00
|
|
|
bi->bi_start = rgd->rd_bitbytes - bytes_left;
|
2018-09-26 16:32:46 -06:00
|
|
|
bi->bi_bytes = bytes;
|
2013-09-11 12:44:02 -06:00
|
|
|
bi->bi_blocks = bytes * GFS2_NBBY;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
bytes_left -= bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bytes_left) {
|
|
|
|
gfs2_consist_rgrpd(rgd);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
bi = rgd->rd_bits + (length - 1);
|
2018-09-26 16:32:46 -06:00
|
|
|
if ((bi->bi_start + bi->bi_bytes) * GFS2_NBBY != rgd->rd_data) {
|
2006-01-16 09:50:04 -07:00
|
|
|
if (gfs2_consist_rgrpd(rgd)) {
|
2007-06-01 07:11:58 -06:00
|
|
|
gfs2_rindex_print(rgd);
|
2006-01-16 09:50:04 -07:00
|
|
|
fs_err(sdp, "start=%u len=%u offset=%u\n",
|
2018-09-26 16:32:46 -06:00
|
|
|
bi->bi_start, bi->bi_bytes, bi->bi_offset);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 08:37:57 -06:00
|
|
|
/**
|
|
|
|
* gfs2_ri_total - Total up the file system space, according to the rindex.
|
2012-04-11 11:03:52 -06:00
|
|
|
* @sdp: the filesystem
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 08:37:57 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
u64 gfs2_ri_total(struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
u64 total_data = 0;
|
|
|
|
struct inode *inode = sdp->sd_rindex;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
char buf[sizeof(struct gfs2_rindex)];
|
|
|
|
int error, rgrps;
|
|
|
|
|
|
|
|
for (rgrps = 0;; rgrps++) {
|
|
|
|
loff_t pos = rgrps * sizeof(struct gfs2_rindex);
|
|
|
|
|
2010-12-07 11:58:56 -07:00
|
|
|
if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 08:37:57 -06:00
|
|
|
break;
|
2012-04-16 09:40:55 -06:00
|
|
|
error = gfs2_internal_read(ip, buf, &pos,
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 08:37:57 -06:00
|
|
|
sizeof(struct gfs2_rindex));
|
|
|
|
if (error != sizeof(struct gfs2_rindex))
|
|
|
|
break;
|
2007-06-01 07:11:58 -06:00
|
|
|
total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 08:37:57 -06:00
|
|
|
}
|
|
|
|
return total_data;
|
|
|
|
}
|
|
|
|
|
2012-03-05 07:20:59 -07:00
|
|
|
static int rgd_insert(struct gfs2_rgrpd *rgd)
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;
|
|
|
|
|
|
|
|
/* Figure out where to put new node */
|
|
|
|
while (*newn) {
|
|
|
|
struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
|
|
|
|
rd_node);
|
|
|
|
|
|
|
|
parent = *newn;
|
|
|
|
if (rgd->rd_addr < cur->rd_addr)
|
|
|
|
newn = &((*newn)->rb_left);
|
|
|
|
else if (rgd->rd_addr > cur->rd_addr)
|
|
|
|
newn = &((*newn)->rb_right);
|
|
|
|
else
|
2012-03-05 07:20:59 -07:00
|
|
|
return -EEXIST;
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&rgd->rd_node, parent, newn);
|
|
|
|
rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
|
2012-03-05 07:20:59 -07:00
|
|
|
sdp->sd_rgrps++;
|
|
|
|
return 0;
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
2007-05-10 15:54:38 -06:00
|
|
|
* read_rindex_entry - Pull in a new resource index entry from the disk
|
2012-04-16 09:40:55 -06:00
|
|
|
* @ip: Pointer to the rindex inode
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
2011-08-31 09:38:29 -06:00
|
|
|
* Returns: 0 on success, > 0 on EOF, error code otherwise
|
2007-05-10 15:54:38 -06:00
|
|
|
*/
|
|
|
|
|
2012-04-16 09:40:55 -06:00
|
|
|
static int read_rindex_entry(struct gfs2_inode *ip)
|
2007-05-10 15:54:38 -06:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2013-12-06 03:16:14 -07:00
|
|
|
const unsigned bsize = sdp->sd_sb.sb_bsize;
|
2007-05-10 15:54:38 -06:00
|
|
|
loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
|
2011-08-31 09:38:29 -06:00
|
|
|
struct gfs2_rindex buf;
|
2007-05-10 15:54:38 -06:00
|
|
|
int error;
|
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
if (pos >= i_size_read(&ip->i_inode))
|
|
|
|
return 1;
|
|
|
|
|
2012-04-16 09:40:55 -06:00
|
|
|
error = gfs2_internal_read(ip, (char *)&buf, &pos,
|
2007-05-10 15:54:38 -06:00
|
|
|
sizeof(struct gfs2_rindex));
|
2011-08-31 09:38:29 -06:00
|
|
|
|
|
|
|
if (error != sizeof(struct gfs2_rindex))
|
|
|
|
return (error == 0) ? 1 : error;
|
2007-05-10 15:54:38 -06:00
|
|
|
|
2008-01-28 16:20:26 -07:00
|
|
|
rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
|
2007-05-10 15:54:38 -06:00
|
|
|
error = -ENOMEM;
|
|
|
|
if (!rgd)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
rgd->rd_sbd = sdp;
|
2011-08-31 09:38:29 -06:00
|
|
|
rgd->rd_addr = be64_to_cpu(buf.ri_addr);
|
|
|
|
rgd->rd_length = be32_to_cpu(buf.ri_length);
|
|
|
|
rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
|
|
|
|
rgd->rd_data = be32_to_cpu(buf.ri_data);
|
|
|
|
rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
|
2012-07-19 06:12:40 -06:00
|
|
|
spin_lock_init(&rgd->rd_rsspin);
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
|
2007-05-10 15:54:38 -06:00
|
|
|
error = compute_bitstructs(rgd);
|
|
|
|
if (error)
|
2011-08-31 09:38:29 -06:00
|
|
|
goto fail;
|
2007-05-10 15:54:38 -06:00
|
|
|
|
2007-06-01 07:11:58 -06:00
|
|
|
error = gfs2_glock_get(sdp, rgd->rd_addr,
|
2007-05-10 15:54:38 -06:00
|
|
|
&gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
|
|
|
|
if (error)
|
2011-08-31 09:38:29 -06:00
|
|
|
goto fail;
|
2007-05-10 15:54:38 -06:00
|
|
|
|
2012-11-14 11:47:37 -07:00
|
|
|
rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
|
2014-10-29 07:02:28 -06:00
|
|
|
rgd->rd_flags &= ~(GFS2_RDF_UPTODATE | GFS2_RDF_PREFERRED);
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
if (rgd->rd_data > sdp->sd_max_rg_data)
|
|
|
|
sdp->sd_max_rg_data = rgd->rd_data;
|
2011-08-31 09:38:29 -06:00
|
|
|
spin_lock(&sdp->sd_rindex_spin);
|
2012-03-05 07:20:59 -07:00
|
|
|
error = rgd_insert(rgd);
|
2011-08-31 09:38:29 -06:00
|
|
|
spin_unlock(&sdp->sd_rindex_spin);
|
GFS2: don't set rgrp gl_object until it's inserted into rgrp tree
Before this patch, function read_rindex_entry would set a rgrp
glock's gl_object pointer to itself before inserting the rgrp into
the rgrp rbtree. The problem is: if another process was also reading
the rgrp in, and had already inserted its newly created rgrp, then
the second call to read_rindex_entry would overwrite that value,
then return a bad return code to the caller. Later, other functions
would reference the now-freed rgrp memory by way of gl_object.
In some cases, that could result in gfs2_rgrp_brelse being called
twice for the same rgrp: once for the failed attempt and once for
the "real" rgrp release. Eventually the kernel would panic.
There are also a number of other things that could go wrong when
a kernel module is accessing freed storage. For example, this could
result in rgrp corruption because the fake rgrp would point to a
fake bitmap in memory too, causing gfs2_inplace_reserve to search
some random memory for free blocks, and find some, since we were
never setting rgd->rd_bits to NULL before freeing it.
This patch fixes the problem by not setting gl_object until we
have successfully inserted the rgrp into the rbtree. Also, it sets
rd_bits to NULL as it frees them, which will ensure any accidental
access to the wrong rgrp will result in a kernel panic rather than
file system corruption, which is preferred.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2016-06-09 13:24:07 -06:00
|
|
|
if (!error) {
|
2017-06-30 06:55:08 -06:00
|
|
|
glock_set_object(rgd->rd_gl, rgd);
|
GFS2: don't set rgrp gl_object until it's inserted into rgrp tree
Before this patch, function read_rindex_entry would set a rgrp
glock's gl_object pointer to itself before inserting the rgrp into
the rgrp rbtree. The problem is: if another process was also reading
the rgrp in, and had already inserted its newly created rgrp, then
the second call to read_rindex_entry would overwrite that value,
then return a bad return code to the caller. Later, other functions
would reference the now-freed rgrp memory by way of gl_object.
In some cases, that could result in gfs2_rgrp_brelse being called
twice for the same rgrp: once for the failed attempt and once for
the "real" rgrp release. Eventually the kernel would panic.
There are also a number of other things that could go wrong when
a kernel module is accessing freed storage. For example, this could
result in rgrp corruption because the fake rgrp would point to a
fake bitmap in memory too, causing gfs2_inplace_reserve to search
some random memory for free blocks, and find some, since we were
never setting rgd->rd_bits to NULL before freeing it.
This patch fixes the problem by not setting gl_object until we
have successfully inserted the rgrp into the rbtree. Also, it sets
rd_bits to NULL as it frees them, which will ensure any accidental
access to the wrong rgrp will result in a kernel panic rather than
file system corruption, which is preferred.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2016-06-09 13:24:07 -06:00
|
|
|
rgd->rd_gl->gl_vm.start = (rgd->rd_addr * bsize) & PAGE_MASK;
|
|
|
|
rgd->rd_gl->gl_vm.end = PAGE_ALIGN((rgd->rd_addr +
|
|
|
|
rgd->rd_length) * bsize) - 1;
|
2012-03-05 07:20:59 -07:00
|
|
|
return 0;
|
GFS2: don't set rgrp gl_object until it's inserted into rgrp tree
Before this patch, function read_rindex_entry would set a rgrp
glock's gl_object pointer to itself before inserting the rgrp into
the rgrp rbtree. The problem is: if another process was also reading
the rgrp in, and had already inserted its newly created rgrp, then
the second call to read_rindex_entry would overwrite that value,
then return a bad return code to the caller. Later, other functions
would reference the now-freed rgrp memory by way of gl_object.
In some cases, that could result in gfs2_rgrp_brelse being called
twice for the same rgrp: once for the failed attempt and once for
the "real" rgrp release. Eventually the kernel would panic.
There are also a number of other things that could go wrong when
a kernel module is accessing freed storage. For example, this could
result in rgrp corruption because the fake rgrp would point to a
fake bitmap in memory too, causing gfs2_inplace_reserve to search
some random memory for free blocks, and find some, since we were
never setting rgd->rd_bits to NULL before freeing it.
This patch fixes the problem by not setting gl_object until we
have successfully inserted the rgrp into the rbtree. Also, it sets
rd_bits to NULL as it frees them, which will ensure any accidental
access to the wrong rgrp will result in a kernel panic rather than
file system corruption, which is preferred.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2016-06-09 13:24:07 -06:00
|
|
|
}
|
2012-03-05 07:20:59 -07:00
|
|
|
|
|
|
|
error = 0; /* someone else read in the rgrp; free it and ignore it */
|
2012-03-22 06:58:30 -06:00
|
|
|
gfs2_glock_put(rgd->rd_gl);
|
2011-08-31 09:38:29 -06:00
|
|
|
|
|
|
|
fail:
|
|
|
|
kfree(rgd->rd_bits);
|
GFS2: don't set rgrp gl_object until it's inserted into rgrp tree
Before this patch, function read_rindex_entry would set a rgrp
glock's gl_object pointer to itself before inserting the rgrp into
the rgrp rbtree. The problem is: if another process was also reading
the rgrp in, and had already inserted its newly created rgrp, then
the second call to read_rindex_entry would overwrite that value,
then return a bad return code to the caller. Later, other functions
would reference the now-freed rgrp memory by way of gl_object.
In some cases, that could result in gfs2_rgrp_brelse being called
twice for the same rgrp: once for the failed attempt and once for
the "real" rgrp release. Eventually the kernel would panic.
There are also a number of other things that could go wrong when
a kernel module is accessing freed storage. For example, this could
result in rgrp corruption because the fake rgrp would point to a
fake bitmap in memory too, causing gfs2_inplace_reserve to search
some random memory for free blocks, and find some, since we were
never setting rgd->rd_bits to NULL before freeing it.
This patch fixes the problem by not setting gl_object until we
have successfully inserted the rgrp into the rbtree. Also, it sets
rd_bits to NULL as it frees them, which will ensure any accidental
access to the wrong rgrp will result in a kernel panic rather than
file system corruption, which is preferred.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2016-06-09 13:24:07 -06:00
|
|
|
rgd->rd_bits = NULL;
|
2011-08-31 09:38:29 -06:00
|
|
|
kmem_cache_free(gfs2_rgrpd_cachep, rgd);
|
2007-05-10 15:54:38 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2014-10-29 07:02:28 -06:00
|
|
|
/**
|
|
|
|
* set_rgrp_preferences - Run all the rgrps, selecting some we prefer to use
|
|
|
|
* @sdp: the GFS2 superblock
|
|
|
|
*
|
|
|
|
* The purpose of this function is to select a subset of the resource groups
|
|
|
|
* and mark them as PREFERRED. We do it in such a way that each node prefers
|
|
|
|
* to use a unique set of rgrps to minimize glock contention.
|
|
|
|
*/
|
|
|
|
static void set_rgrp_preferences(struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
struct gfs2_rgrpd *rgd, *first;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Skip an initial number of rgrps, based on this node's journal ID.
|
|
|
|
That should start each node out on its own set. */
|
|
|
|
rgd = gfs2_rgrpd_get_first(sdp);
|
|
|
|
for (i = 0; i < sdp->sd_lockstruct.ls_jid; i++)
|
|
|
|
rgd = gfs2_rgrpd_get_next(rgd);
|
|
|
|
first = rgd;
|
|
|
|
|
|
|
|
do {
|
|
|
|
rgd->rd_flags |= GFS2_RDF_PREFERRED;
|
|
|
|
for (i = 0; i < sdp->sd_journals; i++) {
|
|
|
|
rgd = gfs2_rgrpd_get_next(rgd);
|
2015-05-05 10:26:04 -06:00
|
|
|
if (!rgd || rgd == first)
|
2014-10-29 07:02:28 -06:00
|
|
|
break;
|
|
|
|
}
|
2015-05-05 10:26:04 -06:00
|
|
|
} while (rgd && rgd != first);
|
2014-10-29 07:02:28 -06:00
|
|
|
}
|
|
|
|
|
2007-05-10 15:54:38 -06:00
|
|
|
/**
|
|
|
|
* gfs2_ri_update - Pull in a new resource index from the disk
|
|
|
|
* @ip: pointer to the rindex inode
|
|
|
|
*
|
2006-01-16 09:50:04 -07:00
|
|
|
* Returns: 0 on successful update, error code otherwise
|
|
|
|
*/
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
static int gfs2_ri_update(struct gfs2_inode *ip)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-01-16 09:50:04 -07:00
|
|
|
int error;
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
do {
|
2012-04-16 09:40:55 -06:00
|
|
|
error = read_rindex_entry(ip);
|
2011-08-31 09:38:29 -06:00
|
|
|
} while (error == 0);
|
|
|
|
|
|
|
|
if (error < 0)
|
|
|
|
return error;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2014-10-29 07:02:28 -06:00
|
|
|
set_rgrp_preferences(sdp);
|
|
|
|
|
2008-01-31 09:31:39 -07:00
|
|
|
sdp->sd_rindex_uptodate = 1;
|
2007-05-10 15:54:38 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
/**
|
2011-08-31 09:38:29 -06:00
|
|
|
* gfs2_rindex_update - Update the rindex if required
|
2006-01-16 09:50:04 -07:00
|
|
|
* @sdp: The GFS2 superblock
|
|
|
|
*
|
|
|
|
* We grab a lock on the rindex inode to make sure that it doesn't
|
|
|
|
* change whilst we are performing an operation. We keep this lock
|
|
|
|
* for quite long periods of time compared to other locks. This
|
|
|
|
* doesn't matter, since it is shared and it is very, very rarely
|
|
|
|
* accessed in the exclusive mode (i.e. only when expanding the filesystem).
|
|
|
|
*
|
|
|
|
* This makes sure that we're using the latest copy of the resource index
|
|
|
|
* special file, which might have been updated if someone expanded the
|
|
|
|
* filesystem (via gfs2_grow utility), which adds new resource groups.
|
|
|
|
*
|
2011-08-31 09:38:29 -06:00
|
|
|
* Returns: 0 on succeess, error code otherwise
|
2006-01-16 09:50:04 -07:00
|
|
|
*/
|
|
|
|
|
2011-08-31 09:38:29 -06:00
|
|
|
int gfs2_rindex_update(struct gfs2_sbd *sdp)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
|
2006-01-16 09:50:04 -07:00
|
|
|
struct gfs2_glock *gl = ip->i_gl;
|
2011-08-31 09:38:29 -06:00
|
|
|
struct gfs2_holder ri_gh;
|
|
|
|
int error = 0;
|
2012-02-24 08:09:14 -07:00
|
|
|
int unlock_required = 0;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
/* Read new copy from disk if we don't have the latest */
|
2008-01-31 09:31:39 -07:00
|
|
|
if (!sdp->sd_rindex_uptodate) {
|
2012-02-24 08:09:14 -07:00
|
|
|
if (!gfs2_glock_is_locked_by_me(gl)) {
|
|
|
|
error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
|
|
|
|
if (error)
|
2012-03-05 07:20:59 -07:00
|
|
|
return error;
|
2012-02-24 08:09:14 -07:00
|
|
|
unlock_required = 1;
|
|
|
|
}
|
2011-08-31 09:38:29 -06:00
|
|
|
if (!sdp->sd_rindex_uptodate)
|
2006-01-16 09:50:04 -07:00
|
|
|
error = gfs2_ri_update(ip);
|
2012-02-24 08:09:14 -07:00
|
|
|
if (unlock_required)
|
|
|
|
gfs2_glock_dq_uninit(&ri_gh);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-01-28 17:38:07 -07:00
|
|
|
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
|
2007-06-01 07:11:58 -06:00
|
|
|
{
|
|
|
|
const struct gfs2_rgrp *str = buf;
|
2008-01-28 17:38:07 -07:00
|
|
|
u32 rg_flags;
|
2007-06-01 07:11:58 -06:00
|
|
|
|
2008-01-28 17:38:07 -07:00
|
|
|
rg_flags = be32_to_cpu(str->rg_flags);
|
2009-05-20 03:48:47 -06:00
|
|
|
rg_flags &= ~GFS2_RDF_MASK;
|
2009-05-21 08:18:19 -06:00
|
|
|
rgd->rd_flags &= GFS2_RDF_MASK;
|
|
|
|
rgd->rd_flags |= rg_flags;
|
2008-11-04 03:25:13 -07:00
|
|
|
rgd->rd_free = be32_to_cpu(str->rg_free);
|
2008-11-04 03:32:57 -07:00
|
|
|
rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
|
2008-11-04 03:19:03 -07:00
|
|
|
rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
|
2017-12-12 10:40:05 -07:00
|
|
|
/* rd_data0, rd_data and rd_bitbytes already set from rindex */
|
2007-06-01 07:11:58 -06:00
|
|
|
}
|
|
|
|
|
2018-07-26 11:59:13 -06:00
|
|
|
static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
|
|
|
|
{
|
|
|
|
const struct gfs2_rgrp *str = buf;
|
|
|
|
|
|
|
|
rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
|
|
|
|
rgl->rl_flags = str->rg_flags;
|
|
|
|
rgl->rl_free = str->rg_free;
|
|
|
|
rgl->rl_dinodes = str->rg_dinodes;
|
|
|
|
rgl->rl_igeneration = str->rg_igeneration;
|
|
|
|
rgl->__pad = 0UL;
|
|
|
|
}
|
|
|
|
|
2008-01-28 17:38:07 -07:00
|
|
|
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
|
2007-06-01 07:11:58 -06:00
|
|
|
{
|
gfs2: Add a next-resource-group pointer to resource groups
Add a new rg_skip field to struct gfs2_rgrp, replacing __pad. The
rg_skip field has the following meaning:
- If rg_skip is zero, it is considered unset and not useful.
- If rg_skip is non-zero, its value will be the number of blocks between
this rgrp's address and the next rgrp's address. This can be used as a
hint by fsck.gfs2 when rebuilding a bad rindex, for example.
This will provide less dependency on the rindex in future, and allow
tools such as fsck.gfs2 to iterate the resource groups without keeping
the rindex around.
The field is updated in gfs2_rgrp_out() so that existing file systems
will have it set. This means that any resource groups that aren't ever
written will not be updated. The final rgrp is a special case as there
is no next rgrp, so it will always have a rg_skip of 0 (unless the fs is
extended).
Before this patch, gfs2_rgrp_out() zeroes the __pad field explicitly, so
the rg_skip field can get set back to 0 in cases where nodes with and
without this patch are mixed in a cluster. In some cases, the field may
bounce between being set by one node and then zeroed by another which
may harm performance slightly, e.g. when two nodes create many small
files. In testing this situation is rare but it becomes more likely as
the filesystem fills up and there are fewer resource groups to choose
from. The problem goes away when all nodes are running with this patch.
Dipping into the space currently occupied by the rg_reserved field would
have resulted in the same problem as it is also explicitly zeroed, so
unfortunately there is no other way around it.
Signed-off-by: Andrew Price <anprice@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2017-12-12 10:37:15 -07:00
|
|
|
struct gfs2_rgrpd *next = gfs2_rgrpd_get_next(rgd);
|
2007-06-01 07:11:58 -06:00
|
|
|
struct gfs2_rgrp *str = buf;
|
2017-12-12 10:42:30 -07:00
|
|
|
u32 crc;
|
2007-06-01 07:11:58 -06:00
|
|
|
|
2009-05-20 03:48:47 -06:00
|
|
|
str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
|
2008-11-04 03:25:13 -07:00
|
|
|
str->rg_free = cpu_to_be32(rgd->rd_free);
|
2008-11-04 03:32:57 -07:00
|
|
|
str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
|
gfs2: Add a next-resource-group pointer to resource groups
Add a new rg_skip field to struct gfs2_rgrp, replacing __pad. The
rg_skip field has the following meaning:
- If rg_skip is zero, it is considered unset and not useful.
- If rg_skip is non-zero, its value will be the number of blocks between
this rgrp's address and the next rgrp's address. This can be used as a
hint by fsck.gfs2 when rebuilding a bad rindex, for example.
This will provide less dependency on the rindex in future, and allow
tools such as fsck.gfs2 to iterate the resource groups without keeping
the rindex around.
The field is updated in gfs2_rgrp_out() so that existing file systems
will have it set. This means that any resource groups that aren't ever
written will not be updated. The final rgrp is a special case as there
is no next rgrp, so it will always have a rg_skip of 0 (unless the fs is
extended).
Before this patch, gfs2_rgrp_out() zeroes the __pad field explicitly, so
the rg_skip field can get set back to 0 in cases where nodes with and
without this patch are mixed in a cluster. In some cases, the field may
bounce between being set by one node and then zeroed by another which
may harm performance slightly, e.g. when two nodes create many small
files. In testing this situation is rare but it becomes more likely as
the filesystem fills up and there are fewer resource groups to choose
from. The problem goes away when all nodes are running with this patch.
Dipping into the space currently occupied by the rg_reserved field would
have resulted in the same problem as it is also explicitly zeroed, so
unfortunately there is no other way around it.
Signed-off-by: Andrew Price <anprice@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2017-12-12 10:37:15 -07:00
|
|
|
if (next == NULL)
|
|
|
|
str->rg_skip = 0;
|
|
|
|
else if (next->rd_addr > rgd->rd_addr)
|
|
|
|
str->rg_skip = cpu_to_be32(next->rd_addr - rgd->rd_addr);
|
2008-11-04 03:19:03 -07:00
|
|
|
str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
|
2017-12-12 10:40:05 -07:00
|
|
|
str->rg_data0 = cpu_to_be64(rgd->rd_data0);
|
|
|
|
str->rg_data = cpu_to_be32(rgd->rd_data);
|
|
|
|
str->rg_bitbytes = cpu_to_be32(rgd->rd_bitbytes);
|
2017-12-12 10:42:30 -07:00
|
|
|
str->rg_crc = 0;
|
|
|
|
crc = gfs2_disk_hash(buf, sizeof(struct gfs2_rgrp));
|
|
|
|
str->rg_crc = cpu_to_be32(crc);
|
2017-12-12 10:40:05 -07:00
|
|
|
|
2007-06-01 07:11:58 -06:00
|
|
|
memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
|
2018-07-26 11:59:13 -06:00
|
|
|
gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, buf);
|
2007-06-01 07:11:58 -06:00
|
|
|
}
|
|
|
|
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
|
|
|
|
struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
|
2019-05-13 08:42:18 -06:00
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
2018-08-15 11:09:49 -06:00
|
|
|
int valid = 1;
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
|
2018-08-15 11:09:49 -06:00
|
|
|
if (rgl->rl_flags != str->rg_flags) {
|
2019-05-13 08:42:18 -06:00
|
|
|
fs_warn(sdp, "GFS2: rgd: %llu lvb flag mismatch %u/%u",
|
|
|
|
(unsigned long long)rgd->rd_addr,
|
2018-08-15 11:09:49 -06:00
|
|
|
be32_to_cpu(rgl->rl_flags), be32_to_cpu(str->rg_flags));
|
|
|
|
valid = 0;
|
|
|
|
}
|
|
|
|
if (rgl->rl_free != str->rg_free) {
|
2019-05-13 08:42:18 -06:00
|
|
|
fs_warn(sdp, "GFS2: rgd: %llu lvb free mismatch %u/%u",
|
|
|
|
(unsigned long long)rgd->rd_addr,
|
|
|
|
be32_to_cpu(rgl->rl_free), be32_to_cpu(str->rg_free));
|
2018-08-15 11:09:49 -06:00
|
|
|
valid = 0;
|
|
|
|
}
|
|
|
|
if (rgl->rl_dinodes != str->rg_dinodes) {
|
2019-05-13 08:42:18 -06:00
|
|
|
fs_warn(sdp, "GFS2: rgd: %llu lvb dinode mismatch %u/%u",
|
|
|
|
(unsigned long long)rgd->rd_addr,
|
|
|
|
be32_to_cpu(rgl->rl_dinodes),
|
|
|
|
be32_to_cpu(str->rg_dinodes));
|
2018-08-15 11:09:49 -06:00
|
|
|
valid = 0;
|
|
|
|
}
|
|
|
|
if (rgl->rl_igeneration != str->rg_igeneration) {
|
2019-05-13 08:42:18 -06:00
|
|
|
fs_warn(sdp, "GFS2: rgd: %llu lvb igen mismatch %llu/%llu",
|
|
|
|
(unsigned long long)rgd->rd_addr,
|
|
|
|
(unsigned long long)be64_to_cpu(rgl->rl_igeneration),
|
|
|
|
(unsigned long long)be64_to_cpu(str->rg_igeneration));
|
2018-08-15 11:09:49 -06:00
|
|
|
valid = 0;
|
|
|
|
}
|
|
|
|
return valid;
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static u32 count_unlinked(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
struct gfs2_bitmap *bi;
|
|
|
|
const u32 length = rgd->rd_length;
|
|
|
|
const u8 *buffer = NULL;
|
|
|
|
u32 i, goal, count = 0;
|
|
|
|
|
|
|
|
for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
|
|
|
|
goal = 0;
|
|
|
|
buffer = bi->bi_bh->b_data + bi->bi_offset;
|
|
|
|
WARN_ON(!buffer_uptodate(bi->bi_bh));
|
2018-09-26 16:32:46 -06:00
|
|
|
while (goal < bi->bi_blocks) {
|
|
|
|
goal = gfs2_bitfit(buffer, bi->bi_bytes, goal,
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
GFS2_BLKST_UNLINKED);
|
|
|
|
if (goal == BFITNOENT)
|
|
|
|
break;
|
|
|
|
count++;
|
|
|
|
goal++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
* gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
|
|
|
|
* @rgd: the struct gfs2_rgrpd describing the RG to read in
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
|
|
|
* Read in all of a Resource Group's header and bitmap blocks.
|
2018-11-05 15:57:24 -07:00
|
|
|
* Caller must eventually call gfs2_rgrp_brelse() to free the bitmaps.
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2014-02-09 06:10:19 -07:00
|
|
|
static int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
struct gfs2_glock *gl = rgd->rd_gl;
|
2007-06-01 07:11:58 -06:00
|
|
|
unsigned int length = rgd->rd_length;
|
2006-01-16 09:50:04 -07:00
|
|
|
struct gfs2_bitmap *bi;
|
|
|
|
unsigned int x, y;
|
|
|
|
int error;
|
|
|
|
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
if (rgd->rd_bits[0].bi_bh != NULL)
|
|
|
|
return 0;
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
for (x = 0; x < length; x++) {
|
|
|
|
bi = rgd->rd_bits + x;
|
2015-11-11 14:00:35 -07:00
|
|
|
error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, 0, &bi->bi_bh);
|
2006-01-16 09:50:04 -07:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (y = length; y--;) {
|
|
|
|
bi = rgd->rd_bits + y;
|
2006-09-21 15:05:23 -06:00
|
|
|
error = gfs2_meta_wait(sdp, bi->bi_bh);
|
2006-01-16 09:50:04 -07:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
2006-06-14 13:32:57 -06:00
|
|
|
if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
|
2006-01-16 09:50:04 -07:00
|
|
|
GFS2_METATYPE_RG)) {
|
|
|
|
error = -EIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-31 09:31:39 -07:00
|
|
|
if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
|
2009-05-21 05:23:12 -06:00
|
|
|
for (x = 0; x < length; x++)
|
|
|
|
clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
|
2008-01-28 17:38:07 -07:00
|
|
|
gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
|
2009-05-21 08:18:19 -06:00
|
|
|
rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
rgd->rd_free_clone = rgd->rd_free;
|
2013-11-25 04:16:25 -07:00
|
|
|
/* max out the rgrp allocation failure point */
|
|
|
|
rgd->rd_extfail_pt = rgd->rd_free;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
2013-06-02 17:53:40 -06:00
|
|
|
if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
|
|
|
|
gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
|
|
|
|
rgd->rd_bits[0].bi_bh->b_data);
|
|
|
|
}
|
|
|
|
else if (sdp->sd_args.ar_rgrplvb) {
|
|
|
|
if (!gfs2_rgrp_lvb_valid(rgd)){
|
|
|
|
gfs2_consist_rgrpd(rgd);
|
|
|
|
error = -EIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (rgd->rd_rgl->rl_unlinked == 0)
|
|
|
|
rgd->rd_flags &= ~GFS2_RDF_CHECK;
|
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
return 0;
|
|
|
|
|
2006-06-14 13:32:57 -06:00
|
|
|
fail:
|
2006-01-16 09:50:04 -07:00
|
|
|
while (x--) {
|
|
|
|
bi = rgd->rd_bits + x;
|
|
|
|
brelse(bi->bi_bh);
|
|
|
|
bi->bi_bh = NULL;
|
|
|
|
gfs2_assert_warn(sdp, !bi->bi_clone);
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2014-02-09 06:10:19 -07:00
|
|
|
static int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
{
|
|
|
|
u32 rl_flags;
|
|
|
|
|
|
|
|
if (rgd->rd_flags & GFS2_RDF_UPTODATE)
|
|
|
|
return 0;
|
|
|
|
|
2013-06-02 17:53:40 -06:00
|
|
|
if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
return gfs2_rgrp_bh_get(rgd);
|
|
|
|
|
|
|
|
rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
|
|
|
|
rl_flags &= ~GFS2_RDF_MASK;
|
|
|
|
rgd->rd_flags &= GFS2_RDF_MASK;
|
gfs2: Don't set GFS2_RDF_UPTODATE when the lvb is updated
The GFS2_RDF_UPTODATE flag in the rgrp is used to determine when
a rgrp buffer is valid. It's cleared when the glock is invalidated,
signifying that the buffer data is now invalid. But before this
patch, function update_rgrp_lvb was setting the flag when it
determined it had a valid lvb. But that's an invalid assumption:
just because you have a valid lvb doesn't mean you have valid
buffers. After all, another node may have made the lvb valid,
and this node just fetched it from the glock via dlm.
Consider this scenario:
1. The file system is mounted with RGRPLVB option.
2. In gfs2_inplace_reserve it locks the rgrp glock EX, but thanks
to GL_SKIP, it skips the gfs2_rgrp_bh_get.
3. Since loops == 0 and the allocation target (ap->target) is
bigger than the largest known chunk of blocks in the rgrp
(rs->rs_rbm.rgd->rd_extfail_pt) it skips that rgrp and bypasses
the call to gfs2_rgrp_bh_get there as well.
4. update_rgrp_lvb sees the lvb MAGIC number is valid, so bypasses
gfs2_rgrp_bh_get, but it still sets sets GFS2_RDF_UPTODATE due
to this invalid assumption.
5. The next time update_rgrp_lvb is called, it sees the bit is set
and just returns 0, assuming both the lvb and rgrp are both
uptodate. But since this is a smaller allocation, or space has
been freed by another node, thus adjusting the lvb values,
it decides to use the rgrp for allocations, with invalid rd_free
due to the fact it was never updated.
This patch changes update_rgrp_lvb so it doesn't set the UPTODATE
flag anymore. That way, it has no choice but to fetch the latest
values.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2018-08-16 09:32:13 -06:00
|
|
|
rgd->rd_flags |= (rl_flags | GFS2_RDF_CHECK);
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
if (rgd->rd_rgl->rl_unlinked == 0)
|
|
|
|
rgd->rd_flags &= ~GFS2_RDF_CHECK;
|
|
|
|
rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
|
|
|
|
rgd->rd_free_clone = rgd->rd_free;
|
|
|
|
rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
|
|
|
|
rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
|
|
|
|
{
|
|
|
|
struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
|
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
|
|
|
|
if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
|
|
|
|
return 0;
|
2014-01-16 06:52:16 -07:00
|
|
|
return gfs2_rgrp_bh_get(rgd);
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
2015-06-05 07:38:57 -06:00
|
|
|
* gfs2_rgrp_brelse - Release RG bitmaps read in with gfs2_rgrp_bh_get()
|
|
|
|
* @rgd: The resource group
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2015-06-05 07:38:57 -06:00
|
|
|
void gfs2_rgrp_brelse(struct gfs2_rgrpd *rgd)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2007-06-01 07:11:58 -06:00
|
|
|
int x, length = rgd->rd_length;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
for (x = 0; x < length; x++) {
|
|
|
|
struct gfs2_bitmap *bi = rgd->rd_bits + x;
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
if (bi->bi_bh) {
|
|
|
|
brelse(bi->bi_bh);
|
|
|
|
bi->bi_bh = NULL;
|
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-06-05 07:38:57 -06:00
|
|
|
/**
|
|
|
|
* gfs2_rgrp_go_unlock - Unlock a rgrp glock
|
|
|
|
* @gh: The glock holder for the resource group
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
|
|
|
|
{
|
|
|
|
struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
|
|
|
|
int demote_requested = test_bit(GLF_DEMOTE, &gh->gh_gl->gl_flags) |
|
|
|
|
test_bit(GLF_PENDING_DEMOTE, &gh->gh_gl->gl_flags);
|
|
|
|
|
|
|
|
if (rgd && demote_requested)
|
|
|
|
gfs2_rgrp_brelse(rgd);
|
|
|
|
}
|
|
|
|
|
2012-02-08 05:58:32 -07:00
|
|
|
int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
struct buffer_head *bh,
|
2012-02-08 05:58:32 -07:00
|
|
|
const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
|
2009-02-09 02:25:01 -07:00
|
|
|
{
|
|
|
|
struct super_block *sb = sdp->sd_vfs;
|
|
|
|
u64 blk;
|
GFS2: Add a "demote a glock" interface to sysfs
This adds a sysfs file called demote_rq to GFS2's
per filesystem directory. Its possible to use this
file to demote arbitrary glocks in exactly the same
way as if a request had come in from a remote node.
This is intended for testing issues relating to caching
of data under glocks. Despite that, the interface is
generic enough to send requests to any type of glock,
but be careful as its not always safe to send an
arbitrary message to an arbitrary glock. For that reason
and to prevent DoS, this interface is restricted to root
only.
The messages look like this:
<type>:<glocknumber> <mode>
Example:
echo -n "2:13324 EX" >/sys/fs/gfs2/unity:myfs/demote_rq
Which means "please demote inode glock (type 2) number 13324 so that
I can get an EX (exclusive) lock". The lock modes are those which
would normally be sent by a remote node in its callback so if you
want to unlock a glock, you use EX, to demote to shared, use SH or PR
(depending on whether you like GFS2 or DLM lock modes better!).
If the glock doesn't exist, you'll get -ENOENT returned. If the
arguments don't make sense, you'll get -EINVAL returned.
The plan is that this interface will be used in combination with
the blktrace patch which I recently posted for comments although
it is, of course, still useful in its own right.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2009-02-12 06:31:58 -07:00
|
|
|
sector_t start = 0;
|
2013-03-22 08:07:24 -06:00
|
|
|
sector_t nr_blks = 0;
|
2009-02-09 02:25:01 -07:00
|
|
|
int rv;
|
|
|
|
unsigned int x;
|
2012-02-08 05:58:32 -07:00
|
|
|
u32 trimmed = 0;
|
|
|
|
u8 diff;
|
2009-02-09 02:25:01 -07:00
|
|
|
|
2018-09-26 16:32:46 -06:00
|
|
|
for (x = 0; x < bi->bi_bytes; x++) {
|
2012-02-08 05:58:32 -07:00
|
|
|
const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
|
|
|
|
clone += bi->bi_offset;
|
|
|
|
clone += x;
|
|
|
|
if (bh) {
|
|
|
|
const u8 *orig = bh->b_data + bi->bi_offset + x;
|
|
|
|
diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
|
|
|
|
} else {
|
|
|
|
diff = ~(*clone | (*clone >> 1));
|
|
|
|
}
|
2009-02-09 02:25:01 -07:00
|
|
|
diff &= 0x55;
|
|
|
|
if (diff == 0)
|
|
|
|
continue;
|
|
|
|
blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
|
|
|
|
while(diff) {
|
|
|
|
if (diff & 1) {
|
2013-03-22 08:07:24 -06:00
|
|
|
if (nr_blks == 0)
|
2009-02-09 02:25:01 -07:00
|
|
|
goto start_new_extent;
|
2013-03-22 08:07:24 -06:00
|
|
|
if ((start + nr_blks) != blk) {
|
|
|
|
if (nr_blks >= minlen) {
|
|
|
|
rv = sb_issue_discard(sb,
|
|
|
|
start, nr_blks,
|
2012-02-08 05:58:32 -07:00
|
|
|
GFP_NOFS, 0);
|
|
|
|
if (rv)
|
|
|
|
goto fail;
|
2013-03-22 08:07:24 -06:00
|
|
|
trimmed += nr_blks;
|
2012-02-08 05:58:32 -07:00
|
|
|
}
|
2013-03-22 08:07:24 -06:00
|
|
|
nr_blks = 0;
|
2009-02-09 02:25:01 -07:00
|
|
|
start_new_extent:
|
|
|
|
start = blk;
|
|
|
|
}
|
2013-03-22 08:07:24 -06:00
|
|
|
nr_blks++;
|
2009-02-09 02:25:01 -07:00
|
|
|
}
|
|
|
|
diff >>= 2;
|
2013-03-22 08:07:24 -06:00
|
|
|
blk++;
|
2009-02-09 02:25:01 -07:00
|
|
|
}
|
|
|
|
}
|
2013-03-22 08:07:24 -06:00
|
|
|
if (nr_blks >= minlen) {
|
|
|
|
rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0);
|
2009-02-09 02:25:01 -07:00
|
|
|
if (rv)
|
|
|
|
goto fail;
|
2013-03-22 08:07:24 -06:00
|
|
|
trimmed += nr_blks;
|
2009-02-09 02:25:01 -07:00
|
|
|
}
|
2012-02-08 05:58:32 -07:00
|
|
|
if (ptrimmed)
|
|
|
|
*ptrimmed = trimmed;
|
|
|
|
return 0;
|
|
|
|
|
2009-02-09 02:25:01 -07:00
|
|
|
fail:
|
2012-02-08 05:58:32 -07:00
|
|
|
if (sdp->sd_args.ar_discard)
|
2018-01-30 10:32:30 -07:00
|
|
|
fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem\n", rv);
|
2009-02-09 02:25:01 -07:00
|
|
|
sdp->sd_args.ar_discard = 0;
|
2012-02-08 05:58:32 -07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_fitrim - Generate discard requests for unused bits of the filesystem
|
|
|
|
* @filp: Any file on the filesystem
|
|
|
|
* @argp: Pointer to the arguments (also used to pass result)
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, otherwise error code
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_fitrim(struct file *filp, void __user *argp)
|
|
|
|
{
|
2013-01-23 15:07:38 -07:00
|
|
|
struct inode *inode = file_inode(filp);
|
2012-02-08 05:58:32 -07:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
struct gfs2_rgrpd *rgd_end;
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
struct fstrim_range r;
|
|
|
|
int ret = 0;
|
|
|
|
u64 amt;
|
|
|
|
u64 trimmed = 0;
|
2012-10-16 03:39:08 -06:00
|
|
|
u64 start, end, minlen;
|
2012-02-08 05:58:32 -07:00
|
|
|
unsigned int x;
|
2012-10-16 03:39:08 -06:00
|
|
|
unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
|
2012-02-08 05:58:32 -07:00
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (!blk_queue_discard(q))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2012-10-16 03:39:07 -06:00
|
|
|
if (copy_from_user(&r, argp, sizeof(r)))
|
2012-02-08 05:58:32 -07:00
|
|
|
return -EFAULT;
|
|
|
|
|
2012-04-04 20:11:16 -06:00
|
|
|
ret = gfs2_rindex_update(sdp);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-10-16 03:39:08 -06:00
|
|
|
start = r.start >> bs_shift;
|
|
|
|
end = start + (r.len >> bs_shift);
|
|
|
|
minlen = max_t(u64, r.minlen,
|
|
|
|
q->limits.discard_granularity) >> bs_shift;
|
|
|
|
|
2013-06-19 15:03:29 -06:00
|
|
|
if (end <= start || minlen > sdp->sd_max_rg_data)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-10-16 03:39:08 -06:00
|
|
|
rgd = gfs2_blk2rgrpd(sdp, start, 0);
|
2013-06-19 15:03:29 -06:00
|
|
|
rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
|
2012-10-16 03:39:08 -06:00
|
|
|
|
2013-06-19 15:03:29 -06:00
|
|
|
if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
|
|
|
|
&& (start > rgd_end->rd_data0 + rgd_end->rd_data))
|
|
|
|
return -EINVAL; /* start is beyond the end of the fs */
|
2012-02-08 05:58:32 -07:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
|
|
|
|
ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
|
|
|
|
/* Trim each bitmap in the rgrp */
|
|
|
|
for (x = 0; x < rgd->rd_length; x++) {
|
|
|
|
struct gfs2_bitmap *bi = rgd->rd_bits + x;
|
2012-10-16 03:39:08 -06:00
|
|
|
ret = gfs2_rgrp_send_discards(sdp,
|
|
|
|
rgd->rd_data0, NULL, bi, minlen,
|
|
|
|
&amt);
|
2012-02-08 05:58:32 -07:00
|
|
|
if (ret) {
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
trimmed += amt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark rgrp as having been trimmed */
|
|
|
|
ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
|
|
|
|
if (ret == 0) {
|
|
|
|
bh = rgd->rd_bits[0].bi_bh;
|
|
|
|
rgd->rd_flags |= GFS2_RGF_TRIMMED;
|
2012-12-14 05:36:02 -07:00
|
|
|
gfs2_trans_add_meta(rgd->rd_gl, bh);
|
2012-02-08 05:58:32 -07:00
|
|
|
gfs2_rgrp_out(rgd, bh->b_data);
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
|
|
|
|
if (rgd == rgd_end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
rgd = gfs2_rgrpd_get_next(rgd);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2013-06-19 15:03:29 -06:00
|
|
|
r.len = trimmed << bs_shift;
|
2012-10-16 03:39:07 -06:00
|
|
|
if (copy_to_user(argp, &r, sizeof(r)))
|
2012-02-08 05:58:32 -07:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return ret;
|
2009-02-09 02:25:01 -07:00
|
|
|
}
|
|
|
|
|
2012-07-19 06:12:40 -06:00
|
|
|
/**
|
|
|
|
* rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
|
|
|
|
* @ip: the inode structure
|
|
|
|
*
|
|
|
|
*/
|
2012-09-10 03:03:50 -06:00
|
|
|
static void rs_insert(struct gfs2_inode *ip)
|
2012-07-19 06:12:40 -06:00
|
|
|
{
|
|
|
|
struct rb_node **newn, *parent = NULL;
|
|
|
|
int rc;
|
2015-07-16 07:28:04 -06:00
|
|
|
struct gfs2_blkreserv *rs = &ip->i_res;
|
2012-07-31 08:21:20 -06:00
|
|
|
struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
|
2012-09-10 03:03:50 -06:00
|
|
|
u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
|
2012-07-19 06:12:40 -06:00
|
|
|
|
|
|
|
BUG_ON(gfs2_rs_active(rs));
|
2012-08-25 11:21:47 -06:00
|
|
|
|
2012-09-10 03:03:50 -06:00
|
|
|
spin_lock(&rgd->rd_rsspin);
|
|
|
|
newn = &rgd->rd_rstree.rb_node;
|
2012-07-19 06:12:40 -06:00
|
|
|
while (*newn) {
|
|
|
|
struct gfs2_blkreserv *cur =
|
|
|
|
rb_entry(*newn, struct gfs2_blkreserv, rs_node);
|
|
|
|
|
|
|
|
parent = *newn;
|
2012-09-10 03:03:50 -06:00
|
|
|
rc = rs_cmp(fsblock, rs->rs_free, cur);
|
2012-07-19 06:12:40 -06:00
|
|
|
if (rc > 0)
|
|
|
|
newn = &((*newn)->rb_right);
|
|
|
|
else if (rc < 0)
|
|
|
|
newn = &((*newn)->rb_left);
|
|
|
|
else {
|
|
|
|
spin_unlock(&rgd->rd_rsspin);
|
2012-09-10 03:03:50 -06:00
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&rs->rs_node, parent, newn);
|
|
|
|
rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
|
|
|
|
|
|
|
|
/* Do our rgrp accounting for the reservation */
|
2012-09-10 03:03:50 -06:00
|
|
|
rgd->rd_reserved += rs->rs_free; /* blocks reserved */
|
2012-07-19 06:12:40 -06:00
|
|
|
spin_unlock(&rgd->rd_rsspin);
|
2012-08-23 08:37:59 -06:00
|
|
|
trace_gfs2_rs(rs, TRACE_RS_INSERT);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
|
GFS2: rgrp free blocks used incorrectly
Before this patch, several functions in rgrp.c checked the value of
rgd->rd_free_clone. That does not take into account blocks that were
reserved by a multi-block reservation. This causes a problem when
space gets tight in the file system. For example, when function
gfs2_inplace_reserve checks to see if a rgrp has enough blocks to
satisfy the request, it can accept a rgrp that it should reject
because, although there are enough blocks to satisfy the request
_now_, those blocks may be reserved for another running process.
A second problem with this occurs when we've reserved the remaining
blocks in an rgrp: function rg_mblk_search() can reject an rgrp
improperly because it calculates:
u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
But rd_reserved includes blocks that the current process just
reserved in its own call to inplace_reserve. For example, it can
reserve the last 128 blocks of an rgrp, then reject that same rgrp
because the above calculates out to free_blocks = 0;
Consequences include, but are not limited to, (1) leaving holes,
and thus increasing file system fragmentation, and (2) reporting
file system is full long before it actually is.
This patch introduces a new function, rgd_free, which returns the
number of clone-free blocks (blocks that are truly free as opposed
to blocks that are still being used because an unlinked file is
still open) minus the number of blocks reserved by processes, but
not counting the blocks we ourselves reserved (because obviously
we need to allocate them).
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2018-05-30 13:05:15 -06:00
|
|
|
/**
|
|
|
|
* rgd_free - return the number of free blocks we can allocate.
|
|
|
|
* @rgd: the resource group
|
|
|
|
*
|
|
|
|
* This function returns the number of free blocks for an rgrp.
|
|
|
|
* That's the clone-free blocks (blocks that are free, not including those
|
|
|
|
* still being used for unlinked files that haven't been deleted.)
|
|
|
|
*
|
|
|
|
* It also subtracts any blocks reserved by someone else, but does not
|
|
|
|
* include free blocks that are still part of our current reservation,
|
|
|
|
* because obviously we can (and will) allocate them.
|
|
|
|
*/
|
|
|
|
static inline u32 rgd_free(struct gfs2_rgrpd *rgd, struct gfs2_blkreserv *rs)
|
|
|
|
{
|
|
|
|
u32 tot_reserved, tot_free;
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(rgd->rd_reserved < rs->rs_free))
|
|
|
|
return 0;
|
|
|
|
tot_reserved = rgd->rd_reserved - rs->rs_free;
|
|
|
|
|
|
|
|
if (rgd->rd_free_clone < tot_reserved)
|
|
|
|
tot_reserved = 0;
|
|
|
|
|
|
|
|
tot_free = rgd->rd_free_clone - tot_reserved;
|
|
|
|
|
|
|
|
return tot_free;
|
|
|
|
}
|
|
|
|
|
2012-07-19 06:12:40 -06:00
|
|
|
/**
|
2012-09-10 03:03:50 -06:00
|
|
|
* rg_mblk_search - find a group of multiple free blocks to form a reservation
|
2012-07-19 06:12:40 -06:00
|
|
|
* @rgd: the resource group descriptor
|
|
|
|
* @ip: pointer to the inode for which we're reserving blocks
|
2013-10-02 04:13:25 -06:00
|
|
|
* @ap: the allocation parameters
|
2012-07-19 06:12:40 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-09-10 03:03:50 -06:00
|
|
|
static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
|
2013-10-02 04:13:25 -06:00
|
|
|
const struct gfs2_alloc_parms *ap)
|
2012-07-19 06:12:40 -06:00
|
|
|
{
|
2012-09-10 03:03:50 -06:00
|
|
|
struct gfs2_rbm rbm = { .rgd = rgd, };
|
|
|
|
u64 goal;
|
2015-07-16 07:28:04 -06:00
|
|
|
struct gfs2_blkreserv *rs = &ip->i_res;
|
2012-09-10 03:03:50 -06:00
|
|
|
u32 extlen;
|
GFS2: rgrp free blocks used incorrectly
Before this patch, several functions in rgrp.c checked the value of
rgd->rd_free_clone. That does not take into account blocks that were
reserved by a multi-block reservation. This causes a problem when
space gets tight in the file system. For example, when function
gfs2_inplace_reserve checks to see if a rgrp has enough blocks to
satisfy the request, it can accept a rgrp that it should reject
because, although there are enough blocks to satisfy the request
_now_, those blocks may be reserved for another running process.
A second problem with this occurs when we've reserved the remaining
blocks in an rgrp: function rg_mblk_search() can reject an rgrp
improperly because it calculates:
u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
But rd_reserved includes blocks that the current process just
reserved in its own call to inplace_reserve. For example, it can
reserve the last 128 blocks of an rgrp, then reject that same rgrp
because the above calculates out to free_blocks = 0;
Consequences include, but are not limited to, (1) leaving holes,
and thus increasing file system fragmentation, and (2) reporting
file system is full long before it actually is.
This patch introduces a new function, rgd_free, which returns the
number of clone-free blocks (blocks that are truly free as opposed
to blocks that are still being used because an unlinked file is
still open) minus the number of blocks reserved by processes, but
not counting the blocks we ourselves reserved (because obviously
we need to allocate them).
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2018-05-30 13:05:15 -06:00
|
|
|
u32 free_blocks = rgd_free(rgd, rs);
|
2012-09-10 03:03:50 -06:00
|
|
|
int ret;
|
2013-05-14 11:04:29 -06:00
|
|
|
struct inode *inode = &ip->i_inode;
|
2012-07-19 06:12:40 -06:00
|
|
|
|
2013-05-14 11:04:29 -06:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
extlen = 1;
|
|
|
|
else {
|
2018-08-30 09:01:50 -06:00
|
|
|
extlen = max_t(u32, atomic_read(&ip->i_sizehint), ap->target);
|
2018-09-25 05:59:31 -06:00
|
|
|
extlen = clamp(extlen, (u32)RGRP_RSRV_MINBLKS, free_blocks);
|
2013-05-14 11:04:29 -06:00
|
|
|
}
|
2012-09-10 03:03:50 -06:00
|
|
|
if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
|
2012-08-25 11:21:47 -06:00
|
|
|
return;
|
|
|
|
|
2012-07-19 06:12:40 -06:00
|
|
|
/* Find bitmap block that contains bits for goal block */
|
|
|
|
if (rgrp_contains_block(rgd, ip->i_goal))
|
2012-09-10 03:03:50 -06:00
|
|
|
goal = ip->i_goal;
|
2012-07-19 06:12:40 -06:00
|
|
|
else
|
2012-09-10 03:03:50 -06:00
|
|
|
goal = rgd->rd_last_alloc + rgd->rd_data0;
|
2012-07-19 06:12:40 -06:00
|
|
|
|
2012-09-10 03:03:50 -06:00
|
|
|
if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
|
|
|
|
return;
|
2012-07-19 06:12:40 -06:00
|
|
|
|
2016-05-02 08:42:49 -06:00
|
|
|
ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &extlen, ip, true);
|
2012-09-10 03:03:50 -06:00
|
|
|
if (ret == 0) {
|
|
|
|
rs->rs_rbm = rbm;
|
|
|
|
rs->rs_free = extlen;
|
|
|
|
rs_insert(ip);
|
2012-12-20 11:23:04 -07:00
|
|
|
} else {
|
|
|
|
if (goal == rgd->rd_last_alloc + rgd->rd_data0)
|
|
|
|
rgd->rd_last_alloc = 0;
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
2011-11-21 09:47:08 -07:00
|
|
|
}
|
|
|
|
|
2012-08-01 13:35:05 -06:00
|
|
|
/**
|
|
|
|
* gfs2_next_unreserved_block - Return next block that is not reserved
|
|
|
|
* @rgd: The resource group
|
|
|
|
* @block: The starting block
|
2012-09-10 03:03:50 -06:00
|
|
|
* @length: The required length
|
2012-08-01 13:35:05 -06:00
|
|
|
* @ip: Ignore any reservations for this inode
|
|
|
|
*
|
|
|
|
* If the block does not appear in any reservation, then return the
|
|
|
|
* block number unchanged. If it does appear in the reservation, then
|
|
|
|
* keep looking through the tree of reservations in order to find the
|
|
|
|
* first block number which is not reserved.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
|
2012-09-10 03:03:50 -06:00
|
|
|
u32 length,
|
2012-08-01 13:35:05 -06:00
|
|
|
const struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
struct gfs2_blkreserv *rs;
|
|
|
|
struct rb_node *n;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
spin_lock(&rgd->rd_rsspin);
|
2012-09-10 03:03:50 -06:00
|
|
|
n = rgd->rd_rstree.rb_node;
|
2012-08-01 13:35:05 -06:00
|
|
|
while (n) {
|
|
|
|
rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
|
2012-09-10 03:03:50 -06:00
|
|
|
rc = rs_cmp(block, length, rs);
|
2012-08-01 13:35:05 -06:00
|
|
|
if (rc < 0)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (rc > 0)
|
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n) {
|
2015-07-16 07:28:04 -06:00
|
|
|
while ((rs_cmp(block, length, rs) == 0) && (&ip->i_res != rs)) {
|
2012-08-01 13:35:05 -06:00
|
|
|
block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
|
2012-09-10 03:03:50 -06:00
|
|
|
n = n->rb_right;
|
2012-08-01 13:35:05 -06:00
|
|
|
if (n == NULL)
|
|
|
|
break;
|
|
|
|
rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&rgd->rd_rsspin);
|
|
|
|
return block;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_reservation_check_and_update - Check for reservations during block alloc
|
|
|
|
* @rbm: The current position in the resource group
|
2012-09-10 03:03:50 -06:00
|
|
|
* @ip: The inode for which we are searching for blocks
|
|
|
|
* @minext: The minimum extent length
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
* @maxext: A pointer to the maximum extent structure
|
2012-08-01 13:35:05 -06:00
|
|
|
*
|
|
|
|
* This checks the current position in the rgrp to see whether there is
|
|
|
|
* a reservation covering this block. If not then this function is a
|
|
|
|
* no-op. If there is, then the position is moved to the end of the
|
|
|
|
* contiguous reservation(s) so that we are pointing at the first
|
|
|
|
* non-reserved block.
|
|
|
|
*
|
|
|
|
* Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
|
2012-09-10 03:03:50 -06:00
|
|
|
const struct gfs2_inode *ip,
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
u32 minext,
|
|
|
|
struct gfs2_extent *maxext)
|
2012-08-01 13:35:05 -06:00
|
|
|
{
|
|
|
|
u64 block = gfs2_rbm_to_block(rbm);
|
2012-09-10 03:03:50 -06:00
|
|
|
u32 extlen = 1;
|
2012-08-01 13:35:05 -06:00
|
|
|
u64 nblock;
|
|
|
|
int ret;
|
|
|
|
|
2012-09-10 03:03:50 -06:00
|
|
|
/*
|
|
|
|
* If we have a minimum extent length, then skip over any extent
|
|
|
|
* which is less than the min extent length in size.
|
|
|
|
*/
|
|
|
|
if (minext) {
|
|
|
|
extlen = gfs2_free_extlen(rbm, minext);
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
if (extlen <= maxext->len)
|
2012-09-10 03:03:50 -06:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the extent which has been found against the reservations
|
|
|
|
* and skip if parts of it are already reserved
|
|
|
|
*/
|
|
|
|
nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
if (nblock == block) {
|
|
|
|
if (!minext || extlen >= minext)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (extlen > maxext->len) {
|
|
|
|
maxext->len = extlen;
|
|
|
|
maxext->rbm = *rbm;
|
|
|
|
}
|
2012-09-10 03:03:50 -06:00
|
|
|
fail:
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
nblock = block + extlen;
|
|
|
|
}
|
2012-08-01 13:35:05 -06:00
|
|
|
ret = gfs2_rbm_from_block(rbm, nblock);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_rbm_find - Look for blocks of a particular state
|
|
|
|
* @rbm: Value/result starting position and final position
|
|
|
|
* @state: The state which we want to find
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
* @minext: Pointer to the requested extent length (NULL for a single block)
|
|
|
|
* This is updated to be the actual reservation size.
|
2012-08-01 13:35:05 -06:00
|
|
|
* @ip: If set, check for reservations
|
|
|
|
* @nowrap: Stop looking at the end of the rgrp, rather than wrapping
|
|
|
|
* around until we've reached the starting point.
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
* - If looking for free blocks, we set GBF_FULL on each bitmap which
|
|
|
|
* has no free blocks in it.
|
2013-11-25 04:16:25 -07:00
|
|
|
* - If looking for free blocks, we set rd_extfail_pt on each rgrp which
|
|
|
|
* has come up short on a free block search.
|
2012-08-01 13:35:05 -06:00
|
|
|
*
|
|
|
|
* Returns: 0 on success, -ENOSPC if there is no block of the requested state
|
|
|
|
*/
|
|
|
|
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
|
2016-05-02 08:42:49 -06:00
|
|
|
const struct gfs2_inode *ip, bool nowrap)
|
2012-08-01 13:35:05 -06:00
|
|
|
{
|
2019-03-14 09:48:48 -06:00
|
|
|
bool scan_from_start = rbm->bii == 0 && rbm->offset == 0;
|
2012-08-01 13:35:05 -06:00
|
|
|
struct buffer_head *bh;
|
2019-03-14 09:48:48 -06:00
|
|
|
int last_bii;
|
2012-08-01 13:35:05 -06:00
|
|
|
u32 offset;
|
|
|
|
u8 *buffer;
|
2019-03-14 09:48:48 -06:00
|
|
|
bool wrapped = false;
|
2012-08-01 13:35:05 -06:00
|
|
|
int ret;
|
2013-09-17 11:12:15 -06:00
|
|
|
struct gfs2_bitmap *bi;
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
|
2012-08-01 13:35:05 -06:00
|
|
|
|
2019-03-14 09:48:48 -06:00
|
|
|
/*
|
|
|
|
* Determine the last bitmap to search. If we're not starting at the
|
|
|
|
* beginning of a bitmap, we need to search that bitmap twice to scan
|
|
|
|
* the entire resource group.
|
2012-08-01 13:35:05 -06:00
|
|
|
*/
|
2019-03-14 09:48:48 -06:00
|
|
|
last_bii = rbm->bii - (rbm->offset == 0);
|
2012-08-01 13:35:05 -06:00
|
|
|
|
|
|
|
while(1) {
|
2013-09-17 11:12:15 -06:00
|
|
|
bi = rbm_bi(rbm);
|
2018-06-18 12:24:13 -06:00
|
|
|
if ((ip == NULL || !gfs2_rs_active(&ip->i_res)) &&
|
|
|
|
test_bit(GBF_FULL, &bi->bi_flags) &&
|
2012-08-01 13:35:05 -06:00
|
|
|
(state == GFS2_BLKST_FREE))
|
|
|
|
goto next_bitmap;
|
|
|
|
|
2013-09-17 11:12:15 -06:00
|
|
|
bh = bi->bi_bh;
|
|
|
|
buffer = bh->b_data + bi->bi_offset;
|
2012-08-01 13:35:05 -06:00
|
|
|
WARN_ON(!buffer_uptodate(bh));
|
2013-09-17 11:12:15 -06:00
|
|
|
if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
|
|
|
|
buffer = bi->bi_clone + bi->bi_offset;
|
2018-09-26 16:32:46 -06:00
|
|
|
offset = gfs2_bitfit(buffer, bi->bi_bytes, rbm->offset, state);
|
2019-03-14 09:48:48 -06:00
|
|
|
if (offset == BFITNOENT) {
|
|
|
|
if (state == GFS2_BLKST_FREE && rbm->offset == 0)
|
|
|
|
set_bit(GBF_FULL, &bi->bi_flags);
|
|
|
|
goto next_bitmap;
|
|
|
|
}
|
2012-08-01 13:35:05 -06:00
|
|
|
rbm->offset = offset;
|
|
|
|
if (ip == NULL)
|
|
|
|
return 0;
|
|
|
|
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
ret = gfs2_reservation_check_and_update(rbm, ip,
|
|
|
|
minext ? *minext : 0,
|
|
|
|
&maxext);
|
2012-08-01 13:35:05 -06:00
|
|
|
if (ret == 0)
|
|
|
|
return 0;
|
2019-03-14 09:48:48 -06:00
|
|
|
if (ret > 0)
|
2012-08-07 11:28:17 -06:00
|
|
|
goto next_iter;
|
2012-08-07 06:47:12 -06:00
|
|
|
if (ret == -E2BIG) {
|
2013-09-17 11:12:15 -06:00
|
|
|
rbm->bii = 0;
|
2012-08-07 06:47:12 -06:00
|
|
|
rbm->offset = 0;
|
|
|
|
goto res_covered_end_of_rgrp;
|
|
|
|
}
|
2012-08-01 13:35:05 -06:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
next_bitmap: /* Find next bitmap in the rgrp */
|
|
|
|
rbm->offset = 0;
|
2013-09-17 11:12:15 -06:00
|
|
|
rbm->bii++;
|
|
|
|
if (rbm->bii == rbm->rgd->rd_length)
|
|
|
|
rbm->bii = 0;
|
2012-08-07 06:47:12 -06:00
|
|
|
res_covered_end_of_rgrp:
|
2019-03-14 09:48:48 -06:00
|
|
|
if (rbm->bii == 0) {
|
|
|
|
if (wrapped)
|
|
|
|
break;
|
|
|
|
wrapped = true;
|
|
|
|
if (nowrap)
|
|
|
|
break;
|
|
|
|
}
|
2012-08-07 11:28:17 -06:00
|
|
|
next_iter:
|
2019-03-14 09:48:48 -06:00
|
|
|
/* Have we scanned the entire resource group? */
|
|
|
|
if (wrapped && rbm->bii > last_bii)
|
2012-08-01 13:35:05 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
if (minext == NULL || state != GFS2_BLKST_FREE)
|
|
|
|
return -ENOSPC;
|
|
|
|
|
2013-11-25 04:16:25 -07:00
|
|
|
/* If the extent was too small, and it's smaller than the smallest
|
|
|
|
to have failed before, remember for future reference that it's
|
|
|
|
useless to search this rgrp again for this amount or more. */
|
2019-03-14 09:48:48 -06:00
|
|
|
if (wrapped && (scan_from_start || rbm->bii > last_bii) &&
|
|
|
|
*minext < rbm->rgd->rd_extfail_pt)
|
2013-11-25 04:16:25 -07:00
|
|
|
rbm->rgd->rd_extfail_pt = *minext;
|
|
|
|
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
/* If the maximum extent we found is big enough to fulfill the
|
|
|
|
minimum requirements, use it anyway. */
|
|
|
|
if (maxext.len) {
|
|
|
|
*rbm = maxext.rbm;
|
|
|
|
*minext = maxext.len;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-01 13:35:05 -06:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
2007-06-08 03:05:33 -06:00
|
|
|
/**
|
|
|
|
* try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
|
|
|
|
* @rgd: The rgrp
|
2012-04-11 11:03:52 -06:00
|
|
|
* @last_unlinked: block address of the last dinode we unlinked
|
|
|
|
* @skip: block address we should explicitly not unlink
|
2007-06-08 03:05:33 -06:00
|
|
|
*
|
2010-04-14 09:58:16 -06:00
|
|
|
* Returns: 0 if no error
|
|
|
|
* The inode, if one has been found, in inode.
|
2007-06-08 03:05:33 -06:00
|
|
|
*/
|
|
|
|
|
2010-11-03 14:01:07 -06:00
|
|
|
static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
|
2007-06-08 03:05:33 -06:00
|
|
|
{
|
2012-08-01 13:35:05 -06:00
|
|
|
u64 block;
|
2007-08-08 15:52:09 -06:00
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
2010-11-03 14:01:07 -06:00
|
|
|
struct gfs2_glock *gl;
|
|
|
|
struct gfs2_inode *ip;
|
|
|
|
int error;
|
|
|
|
int found = 0;
|
2013-09-17 11:12:15 -06:00
|
|
|
struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
|
2007-06-08 03:05:33 -06:00
|
|
|
|
2012-08-01 13:35:05 -06:00
|
|
|
while (1) {
|
2007-08-08 15:52:09 -06:00
|
|
|
down_write(&sdp->sd_log_flush_lock);
|
GFS2: If requested is too large, use the largest extent in the rgrp
Here is a second try at a patch I posted earlier, which also implements
suggestions Steve made:
Before this patch, GFS2 would keep searching through all the rgrps
until it found one that had a chunk of free blocks big enough to
satisfy the size hint, which is based on the file write size,
regardless of whether the chunk was big enough to perform the write.
However, when doing big writes there may not be a large enough
chunk of free blocks in any rgrp, due to file system fragmentation.
The largest chunk may be big enough to satisfy the write request,
but it may not meet the ideal reservation size from the "size hint".
The writes would slow to a crawl because every write would search
every rgrp, then finally give up and default to a single-block write.
In my case, performance would drop from 425MB/s to 18KB/s, or 24000
times slower.
This patch basically makes it so that if we can't find a contiguous
chunk of blocks big enough to satisfy the sizehint, we'll use the
largest chunk of blocks we found that will still contain the write.
It does so by keeping track of the largest run of blocks within the
rgrp.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:55:52 -07:00
|
|
|
error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, NULL, NULL,
|
2016-05-02 08:42:49 -06:00
|
|
|
true);
|
2007-08-08 15:52:09 -06:00
|
|
|
up_write(&sdp->sd_log_flush_lock);
|
2012-08-01 13:35:05 -06:00
|
|
|
if (error == -ENOSPC)
|
|
|
|
break;
|
|
|
|
if (WARN_ON_ONCE(error))
|
2007-07-12 15:58:50 -06:00
|
|
|
break;
|
2011-11-21 09:47:08 -07:00
|
|
|
|
2012-08-01 13:35:05 -06:00
|
|
|
block = gfs2_rbm_to_block(&rbm);
|
|
|
|
if (gfs2_rbm_from_block(&rbm, block + 1))
|
|
|
|
break;
|
|
|
|
if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
|
2007-06-08 03:05:33 -06:00
|
|
|
continue;
|
2012-08-01 13:35:05 -06:00
|
|
|
if (block == skip)
|
2009-07-10 14:13:38 -06:00
|
|
|
continue;
|
2012-08-01 13:35:05 -06:00
|
|
|
*last_unlinked = block;
|
2010-11-03 14:01:07 -06:00
|
|
|
|
2015-12-04 11:57:00 -07:00
|
|
|
error = gfs2_glock_get(sdp, block, &gfs2_iopen_glops, CREATE, &gl);
|
2010-11-03 14:01:07 -06:00
|
|
|
if (error)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* If the inode is already in cache, we can ignore it here
|
|
|
|
* because the existing inode disposal code will deal with
|
|
|
|
* it when all refs have gone away. Accessing gl_object like
|
|
|
|
* this is not safe in general. Here it is ok because we do
|
|
|
|
* not dereference the pointer, and we only need an approx
|
|
|
|
* answer to whether it is NULL or not.
|
|
|
|
*/
|
|
|
|
ip = gl->gl_object;
|
|
|
|
|
|
|
|
if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
|
|
|
|
gfs2_glock_put(gl);
|
|
|
|
else
|
|
|
|
found++;
|
|
|
|
|
|
|
|
/* Limit reclaim to sensible number of tasks */
|
2011-03-17 14:19:58 -06:00
|
|
|
if (found > NR_CPUS)
|
2010-11-03 14:01:07 -06:00
|
|
|
return;
|
2007-06-08 03:05:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
rgd->rd_flags &= ~GFS2_RDF_CHECK;
|
2010-11-03 14:01:07 -06:00
|
|
|
return;
|
2007-06-08 03:05:33 -06:00
|
|
|
}
|
|
|
|
|
2012-10-31 03:58:42 -06:00
|
|
|
/**
|
|
|
|
* gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
|
|
|
|
* @rgd: The rgrp in question
|
|
|
|
* @loops: An indication of how picky we can be (0=very, 1=less so)
|
|
|
|
*
|
|
|
|
* This function uses the recently added glock statistics in order to
|
|
|
|
* figure out whether a parciular resource group is suffering from
|
|
|
|
* contention from multiple nodes. This is done purely on the basis
|
|
|
|
* of timings, since this is the only data we have to work with and
|
|
|
|
* our aim here is to reject a resource group which is highly contended
|
|
|
|
* but (very important) not to do this too often in order to ensure that
|
|
|
|
* we do not land up introducing fragmentation by changing resource
|
|
|
|
* groups when not actually required.
|
|
|
|
*
|
|
|
|
* The calculation is fairly simple, we want to know whether the SRTTB
|
|
|
|
* (i.e. smoothed round trip time for blocking operations) to acquire
|
|
|
|
* the lock for this rgrp's glock is significantly greater than the
|
|
|
|
* time taken for resource groups on average. We introduce a margin in
|
|
|
|
* the form of the variable @var which is computed as the sum of the two
|
|
|
|
* respective variences, and multiplied by a factor depending on @loops
|
|
|
|
* and whether we have a lot of data to base the decision on. This is
|
|
|
|
* then tested against the square difference of the means in order to
|
|
|
|
* decide whether the result is statistically significant or not.
|
|
|
|
*
|
|
|
|
* Returns: A boolean verdict on the congestion status
|
|
|
|
*/
|
|
|
|
|
|
|
|
static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
|
|
|
|
{
|
|
|
|
const struct gfs2_glock *gl = rgd->rd_gl;
|
2015-03-16 10:52:05 -06:00
|
|
|
const struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
|
2012-10-31 03:58:42 -06:00
|
|
|
struct gfs2_lkstats *st;
|
2015-08-27 11:51:45 -06:00
|
|
|
u64 r_dcount, l_dcount;
|
|
|
|
u64 l_srttb, a_srttb = 0;
|
2012-10-31 03:58:42 -06:00
|
|
|
s64 srttb_diff;
|
2015-08-27 11:51:45 -06:00
|
|
|
u64 sqr_diff;
|
|
|
|
u64 var;
|
2015-04-22 10:24:12 -06:00
|
|
|
int cpu, nonzero = 0;
|
2012-10-31 03:58:42 -06:00
|
|
|
|
|
|
|
preempt_disable();
|
2014-11-19 11:27:11 -07:00
|
|
|
for_each_present_cpu(cpu) {
|
|
|
|
st = &per_cpu_ptr(sdp->sd_lkstats, cpu)->lkstats[LM_TYPE_RGRP];
|
2015-04-22 10:24:12 -06:00
|
|
|
if (st->stats[GFS2_LKS_SRTTB]) {
|
|
|
|
a_srttb += st->stats[GFS2_LKS_SRTTB];
|
|
|
|
nonzero++;
|
|
|
|
}
|
2014-11-19 11:27:11 -07:00
|
|
|
}
|
2012-10-31 03:58:42 -06:00
|
|
|
st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
|
2015-04-22 10:24:12 -06:00
|
|
|
if (nonzero)
|
|
|
|
do_div(a_srttb, nonzero);
|
2012-10-31 03:58:42 -06:00
|
|
|
r_dcount = st->stats[GFS2_LKS_DCOUNT];
|
|
|
|
var = st->stats[GFS2_LKS_SRTTVARB] +
|
|
|
|
gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
|
|
|
|
preempt_enable();
|
|
|
|
|
|
|
|
l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
|
|
|
|
l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
|
|
|
|
|
2014-11-19 11:27:11 -07:00
|
|
|
if ((l_dcount < 1) || (r_dcount < 1) || (a_srttb == 0))
|
2012-10-31 03:58:42 -06:00
|
|
|
return false;
|
|
|
|
|
2014-11-19 11:27:11 -07:00
|
|
|
srttb_diff = a_srttb - l_srttb;
|
2012-10-31 03:58:42 -06:00
|
|
|
sqr_diff = srttb_diff * srttb_diff;
|
|
|
|
|
|
|
|
var *= 2;
|
|
|
|
if (l_dcount < 8 || r_dcount < 8)
|
|
|
|
var *= 2;
|
|
|
|
if (loops == 1)
|
|
|
|
var *= 2;
|
|
|
|
|
|
|
|
return ((srttb_diff < 0) && (sqr_diff > var));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_rgrp_used_recently
|
|
|
|
* @rs: The block reservation with the rgrp to test
|
|
|
|
* @msecs: The time limit in milliseconds
|
|
|
|
*
|
|
|
|
* Returns: True if the rgrp glock has been used within the time limit
|
|
|
|
*/
|
|
|
|
static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
|
|
|
|
u64 msecs)
|
|
|
|
{
|
|
|
|
u64 tdiff;
|
|
|
|
|
|
|
|
tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
|
|
|
|
rs->rs_rbm.rgd->rd_gl->gl_dstamp));
|
|
|
|
|
|
|
|
return tdiff > (msecs * 1000 * 1000);
|
|
|
|
}
|
|
|
|
|
2012-10-31 04:37:10 -06:00
|
|
|
static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
|
|
|
u32 skip;
|
|
|
|
|
|
|
|
get_random_bytes(&skip, sizeof(skip));
|
|
|
|
return skip % sdp->sd_rgrps;
|
|
|
|
}
|
|
|
|
|
2012-08-25 11:21:47 -06:00
|
|
|
static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
|
|
|
|
{
|
|
|
|
struct gfs2_rgrpd *rgd = *pos;
|
2012-11-13 07:50:35 -07:00
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
2012-08-25 11:21:47 -06:00
|
|
|
|
|
|
|
rgd = gfs2_rgrpd_get_next(rgd);
|
|
|
|
if (rgd == NULL)
|
2012-11-13 07:50:35 -07:00
|
|
|
rgd = gfs2_rgrpd_get_first(sdp);
|
2012-08-25 11:21:47 -06:00
|
|
|
*pos = rgd;
|
|
|
|
if (rgd != begin) /* If we didn't wrap */
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-10-29 07:02:28 -06:00
|
|
|
/**
|
|
|
|
* fast_to_acquire - determine if a resource group will be fast to acquire
|
|
|
|
*
|
|
|
|
* If this is one of our preferred rgrps, it should be quicker to acquire,
|
|
|
|
* because we tried to set ourselves up as dlm lock master.
|
|
|
|
*/
|
|
|
|
static inline int fast_to_acquire(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
struct gfs2_glock *gl = rgd->rd_gl;
|
|
|
|
|
|
|
|
if (gl->gl_state != LM_ST_UNLOCKED && list_empty(&gl->gl_holders) &&
|
|
|
|
!test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
|
|
|
|
!test_bit(GLF_DEMOTE, &gl->gl_flags))
|
|
|
|
return 1;
|
|
|
|
if (rgd->rd_flags & GFS2_RDF_PREFERRED)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
2012-06-13 21:03:56 -06:00
|
|
|
* gfs2_inplace_reserve - Reserve space in the filesystem
|
2006-01-16 09:50:04 -07:00
|
|
|
* @ip: the inode to reserve space for
|
2013-10-02 04:13:25 -06:00
|
|
|
* @ap: the allocation parameters
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
2015-03-18 11:04:37 -06:00
|
|
|
* We try our best to find an rgrp that has at least ap->target blocks
|
|
|
|
* available. After a couple of passes (loops == 2), the prospects of finding
|
|
|
|
* such an rgrp diminish. At this stage, we return the first rgrp that has
|
2018-10-02 03:22:41 -06:00
|
|
|
* at least ap->min_target blocks available. Either way, we set ap->allowed to
|
2015-03-18 11:04:37 -06:00
|
|
|
* the number of blocks available in the chosen rgrp.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success,
|
|
|
|
* -ENOMEM if a suitable rgrp can't be found
|
|
|
|
* errno otherwise
|
2006-01-16 09:50:04 -07:00
|
|
|
*/
|
|
|
|
|
2015-03-18 11:04:37 -06:00
|
|
|
int gfs2_inplace_reserve(struct gfs2_inode *ip, struct gfs2_alloc_parms *ap)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2012-07-19 06:12:40 -06:00
|
|
|
struct gfs2_rgrpd *begin = NULL;
|
2015-07-16 07:28:04 -06:00
|
|
|
struct gfs2_blkreserv *rs = &ip->i_res;
|
2012-10-31 03:58:42 -06:00
|
|
|
int error = 0, rg_locked, flags = 0;
|
2012-06-13 21:03:56 -06:00
|
|
|
u64 last_unlinked = NO_BLOCK;
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
int loops = 0;
|
GFS2: rgrp free blocks used incorrectly
Before this patch, several functions in rgrp.c checked the value of
rgd->rd_free_clone. That does not take into account blocks that were
reserved by a multi-block reservation. This causes a problem when
space gets tight in the file system. For example, when function
gfs2_inplace_reserve checks to see if a rgrp has enough blocks to
satisfy the request, it can accept a rgrp that it should reject
because, although there are enough blocks to satisfy the request
_now_, those blocks may be reserved for another running process.
A second problem with this occurs when we've reserved the remaining
blocks in an rgrp: function rg_mblk_search() can reject an rgrp
improperly because it calculates:
u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
But rd_reserved includes blocks that the current process just
reserved in its own call to inplace_reserve. For example, it can
reserve the last 128 blocks of an rgrp, then reject that same rgrp
because the above calculates out to free_blocks = 0;
Consequences include, but are not limited to, (1) leaving holes,
and thus increasing file system fragmentation, and (2) reporting
file system is full long before it actually is.
This patch introduces a new function, rgd_free, which returns the
number of clone-free blocks (blocks that are truly free as opposed
to blocks that are still being used because an unlinked file is
still open) minus the number of blocks reserved by processes, but
not counting the blocks we ourselves reserved (because obviously
we need to allocate them).
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2018-05-30 13:05:15 -06:00
|
|
|
u32 free_blocks, skip = 0;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
if (sdp->sd_args.ar_rgrplvb)
|
|
|
|
flags |= GL_SKIP;
|
2013-10-02 04:13:25 -06:00
|
|
|
if (gfs2_assert_warn(sdp, ap->target))
|
2012-08-25 11:21:47 -06:00
|
|
|
return -EINVAL;
|
2012-07-19 06:12:40 -06:00
|
|
|
if (gfs2_rs_active(rs)) {
|
2012-07-31 08:21:20 -06:00
|
|
|
begin = rs->rs_rbm.rgd;
|
2018-06-21 06:42:37 -06:00
|
|
|
} else if (rs->rs_rbm.rgd &&
|
|
|
|
rgrp_contains_block(rs->rs_rbm.rgd, ip->i_goal)) {
|
|
|
|
begin = rs->rs_rbm.rgd;
|
2012-07-19 06:12:40 -06:00
|
|
|
} else {
|
2014-09-18 20:40:28 -06:00
|
|
|
check_and_update_goal(ip);
|
2012-07-31 08:21:20 -06:00
|
|
|
rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
2013-10-02 04:13:25 -06:00
|
|
|
if (S_ISDIR(ip->i_inode.i_mode) && (ap->aflags & GFS2_AF_ORLOV))
|
2012-10-31 04:37:10 -06:00
|
|
|
skip = gfs2_orlov_skip(ip);
|
2012-07-31 08:21:20 -06:00
|
|
|
if (rs->rs_rbm.rgd == NULL)
|
GFS2: Use rbtree for resource groups and clean up bitmap buffer ref count scheme
Here is an update of Bob's original rbtree patch which, in addition, also
resolves the rather strange ref counting that was being done relating to
the bitmap blocks.
Originally we had a dual system for journaling resource groups. The metadata
blocks were journaled and also the rgrp itself was added to a list. The reason
for adding the rgrp to the list in the journal was so that the "repolish
clones" code could be run to update the free space, and potentially send any
discard requests when the log was flushed. This was done by comparing the
"cloned" bitmap with what had been written back on disk during the transaction
commit.
Due to this, there was a requirement to hang on to the rgrps' bitmap buffers
until the journal had been flushed. For that reason, there was a rather
complicated set up in the ->go_lock ->go_unlock functions for rgrps involving
both a mutex and a spinlock (the ->sd_rindex_spin) to maintain a reference
count on the buffers.
However, the journal maintains a reference count on the buffers anyway, since
they are being journaled as metadata buffers. So by moving the code which deals
with the post-journal accounting for bitmap blocks to the metadata journaling
code, we can entirely dispense with the rather strange buffer ref counting
scheme and also the requirement to journal the rgrps.
The net result of all this is that the ->sd_rindex_spin is left to do exactly
one job, and that is to look after the rbtree or rgrps.
This patch is designed to be a stepping stone towards using RCU for the rbtree
of resource groups, however the reduction in the number of uses of the
->sd_rindex_spin is likely to have benefits for multi-threaded workloads,
anyway.
The patch retains ->go_lock and ->go_unlock for rgrps, however these maybe also
be removed in future in favour of calling the functions directly where required
in the code. That will allow locking of resource groups without needing to
actually read them in - something that could be useful in speeding up statfs.
In the mean time though it is valid to dereference ->bi_bh only when the rgrp
is locked. This is basically the same rule as before, modulo the references not
being valid until the following journal flush.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Cc: Benjamin Marzinski <bmarzins@redhat.com>
2011-08-31 02:53:19 -06:00
|
|
|
return -EBADSLT;
|
|
|
|
|
|
|
|
while (loops < 3) {
|
2012-08-25 11:21:47 -06:00
|
|
|
rg_locked = 1;
|
|
|
|
|
|
|
|
if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
|
|
|
|
rg_locked = 0;
|
2012-10-31 04:37:10 -06:00
|
|
|
if (skip && skip--)
|
|
|
|
goto next_rgrp;
|
2014-10-29 07:02:28 -06:00
|
|
|
if (!gfs2_rs_active(rs)) {
|
|
|
|
if (loops == 0 &&
|
|
|
|
!fast_to_acquire(rs->rs_rbm.rgd))
|
|
|
|
goto next_rgrp;
|
|
|
|
if ((loops < 2) &&
|
|
|
|
gfs2_rgrp_used_recently(rs, 1000) &&
|
|
|
|
gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
|
|
|
|
goto next_rgrp;
|
|
|
|
}
|
2012-07-31 08:21:20 -06:00
|
|
|
error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
|
2012-07-19 06:12:40 -06:00
|
|
|
LM_ST_EXCLUSIVE, flags,
|
2018-08-30 09:01:50 -06:00
|
|
|
&ip->i_rgd_gh);
|
2012-08-25 11:21:47 -06:00
|
|
|
if (unlikely(error))
|
|
|
|
return error;
|
2012-10-31 03:58:42 -06:00
|
|
|
if (!gfs2_rs_active(rs) && (loops < 2) &&
|
|
|
|
gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
|
|
|
|
goto skip_rgrp;
|
2012-08-25 11:21:47 -06:00
|
|
|
if (sdp->sd_args.ar_rgrplvb) {
|
2012-07-31 08:21:20 -06:00
|
|
|
error = update_rgrp_lvb(rs->rs_rbm.rgd);
|
2012-08-25 11:21:47 -06:00
|
|
|
if (unlikely(error)) {
|
2018-08-30 09:01:50 -06:00
|
|
|
gfs2_glock_dq_uninit(&ip->i_rgd_gh);
|
GFS2: Use lvbs for storing rgrp information with mount option
Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb. Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.
The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time. But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.
Enabling the resource groups lvbs is done via the rgrplvb mount option. If
this option isn't set, the lvbs will still be set and updated, but they won't
be verfied or used by the filesystem. To safely turn on this option, all of
the nodes mounting the filesystem must be running code with this patch, and
the filesystem must have been completely unmounted since they were updated.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2012-05-29 22:01:09 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
2007-11-29 13:13:54 -07:00
|
|
|
}
|
2012-06-13 21:03:56 -06:00
|
|
|
|
2018-10-02 03:22:41 -06:00
|
|
|
/* Skip unusable resource groups */
|
2013-11-25 04:16:25 -07:00
|
|
|
if ((rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC |
|
|
|
|
GFS2_RDF_ERROR)) ||
|
2015-03-18 11:04:37 -06:00
|
|
|
(loops == 0 && ap->target > rs->rs_rbm.rgd->rd_extfail_pt))
|
2012-08-25 11:21:47 -06:00
|
|
|
goto skip_rgrp;
|
|
|
|
|
|
|
|
if (sdp->sd_args.ar_rgrplvb)
|
|
|
|
gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
|
|
|
|
|
|
|
|
/* Get a reservation if we don't already have one */
|
|
|
|
if (!gfs2_rs_active(rs))
|
2013-10-02 04:13:25 -06:00
|
|
|
rg_mblk_search(rs->rs_rbm.rgd, ip, ap);
|
2012-08-25 11:21:47 -06:00
|
|
|
|
|
|
|
/* Skip rgrps when we can't get a reservation on first pass */
|
|
|
|
if (!gfs2_rs_active(rs) && (loops < 1))
|
|
|
|
goto check_rgrp;
|
|
|
|
|
|
|
|
/* If rgrp has enough free space, use it */
|
GFS2: rgrp free blocks used incorrectly
Before this patch, several functions in rgrp.c checked the value of
rgd->rd_free_clone. That does not take into account blocks that were
reserved by a multi-block reservation. This causes a problem when
space gets tight in the file system. For example, when function
gfs2_inplace_reserve checks to see if a rgrp has enough blocks to
satisfy the request, it can accept a rgrp that it should reject
because, although there are enough blocks to satisfy the request
_now_, those blocks may be reserved for another running process.
A second problem with this occurs when we've reserved the remaining
blocks in an rgrp: function rg_mblk_search() can reject an rgrp
improperly because it calculates:
u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
But rd_reserved includes blocks that the current process just
reserved in its own call to inplace_reserve. For example, it can
reserve the last 128 blocks of an rgrp, then reject that same rgrp
because the above calculates out to free_blocks = 0;
Consequences include, but are not limited to, (1) leaving holes,
and thus increasing file system fragmentation, and (2) reporting
file system is full long before it actually is.
This patch introduces a new function, rgd_free, which returns the
number of clone-free blocks (blocks that are truly free as opposed
to blocks that are still being used because an unlinked file is
still open) minus the number of blocks reserved by processes, but
not counting the blocks we ourselves reserved (because obviously
we need to allocate them).
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2018-05-30 13:05:15 -06:00
|
|
|
free_blocks = rgd_free(rs->rs_rbm.rgd, rs);
|
|
|
|
if (free_blocks >= ap->target ||
|
2015-03-18 11:04:37 -06:00
|
|
|
(loops == 2 && ap->min_target &&
|
GFS2: rgrp free blocks used incorrectly
Before this patch, several functions in rgrp.c checked the value of
rgd->rd_free_clone. That does not take into account blocks that were
reserved by a multi-block reservation. This causes a problem when
space gets tight in the file system. For example, when function
gfs2_inplace_reserve checks to see if a rgrp has enough blocks to
satisfy the request, it can accept a rgrp that it should reject
because, although there are enough blocks to satisfy the request
_now_, those blocks may be reserved for another running process.
A second problem with this occurs when we've reserved the remaining
blocks in an rgrp: function rg_mblk_search() can reject an rgrp
improperly because it calculates:
u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
But rd_reserved includes blocks that the current process just
reserved in its own call to inplace_reserve. For example, it can
reserve the last 128 blocks of an rgrp, then reject that same rgrp
because the above calculates out to free_blocks = 0;
Consequences include, but are not limited to, (1) leaving holes,
and thus increasing file system fragmentation, and (2) reporting
file system is full long before it actually is.
This patch introduces a new function, rgd_free, which returns the
number of clone-free blocks (blocks that are truly free as opposed
to blocks that are still being used because an unlinked file is
still open) minus the number of blocks reserved by processes, but
not counting the blocks we ourselves reserved (because obviously
we need to allocate them).
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2018-05-30 13:05:15 -06:00
|
|
|
free_blocks >= ap->min_target)) {
|
|
|
|
ap->allowed = free_blocks;
|
2012-08-25 11:21:47 -06:00
|
|
|
return 0;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
2012-08-25 11:21:47 -06:00
|
|
|
check_rgrp:
|
|
|
|
/* Check for unlinked inodes which can be reclaimed */
|
|
|
|
if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
|
|
|
|
try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
|
|
|
|
ip->i_no_addr);
|
|
|
|
skip_rgrp:
|
GFS2: Drop inadequate rgrps from the reservation tree
This is just basically a resend of a patch I posted earlier.
It didn't change from its original, except in diff offsets, etc:
This patch fixes a bug in the GFS2 block allocation code. The problem
starts if a process already has a multi-block reservation, but for
some reason, another process disqualifies it from further allocations.
For example, the other process might set on the GFS2_RDF_ERROR bit.
The process holding the reservation jumps to label skip_rgrp, but
that label comes after the code that removes the reservation from the
tree. Therefore, the no longer usable reservation is not removed from
the rgrp's reservations tree; it's lost. Eventually, the lost reservation
causes the count of reserved blocks to get off, and eventually that
causes a BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free) to trigger.
This patch moves the call to after label skip_rgrp so that the
disqualified reservation is properly removed from the tree, thus keeping
the rgrp rd_reserved count sane.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2013-11-06 08:58:00 -07:00
|
|
|
/* Drop reservation, if we couldn't use reserved rgrp */
|
|
|
|
if (gfs2_rs_active(rs))
|
|
|
|
gfs2_rs_deltree(rs);
|
|
|
|
|
2012-08-25 11:21:47 -06:00
|
|
|
/* Unlock rgrp if required */
|
|
|
|
if (!rg_locked)
|
2018-08-30 09:01:50 -06:00
|
|
|
gfs2_glock_dq_uninit(&ip->i_rgd_gh);
|
2012-08-25 11:21:47 -06:00
|
|
|
next_rgrp:
|
|
|
|
/* Find the next rgrp, and continue looking */
|
|
|
|
if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
|
|
|
|
continue;
|
2012-10-31 04:37:10 -06:00
|
|
|
if (skip)
|
|
|
|
continue;
|
2012-08-25 11:21:47 -06:00
|
|
|
|
|
|
|
/* If we've scanned all the rgrps, but found no free blocks
|
|
|
|
* then this checks for some less likely conditions before
|
|
|
|
* trying again.
|
|
|
|
*/
|
|
|
|
loops++;
|
|
|
|
/* Check that fs hasn't grown if writing to rindex */
|
|
|
|
if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
|
|
|
|
error = gfs2_ri_update(ip);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
/* Flushing the log may release space */
|
|
|
|
if (loops == 2)
|
2018-01-08 08:34:17 -07:00
|
|
|
gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
|
|
|
|
GFS2_LFC_INPLACE_RESERVE);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2012-08-25 11:21:47 -06:00
|
|
|
return -ENOSPC;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_inplace_release - release an inplace reservation
|
|
|
|
* @ip: the inode the reservation was taken out on
|
|
|
|
*
|
|
|
|
* Release a reservation made by gfs2_inplace_reserve().
|
|
|
|
*/
|
|
|
|
|
|
|
|
void gfs2_inplace_release(struct gfs2_inode *ip)
|
|
|
|
{
|
2018-08-30 09:01:50 -06:00
|
|
|
if (gfs2_holder_initialized(&ip->i_rgd_gh))
|
|
|
|
gfs2_glock_dq_uninit(&ip->i_rgd_gh);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2011-11-21 09:47:08 -07:00
|
|
|
/**
|
|
|
|
* gfs2_alloc_extent - allocate an extent from a given bitmap
|
2012-07-31 08:21:20 -06:00
|
|
|
* @rbm: the resource group information
|
2011-11-21 09:47:08 -07:00
|
|
|
* @dinode: TRUE if the first block we allocate is for a dinode
|
2012-08-13 04:14:57 -06:00
|
|
|
* @n: The extent length (value/result)
|
2011-11-21 09:47:08 -07:00
|
|
|
*
|
2012-08-13 04:14:57 -06:00
|
|
|
* Add the bitmap buffer to the transaction.
|
2011-11-21 09:47:08 -07:00
|
|
|
* Set the found bits to @new_state to change block's allocation state.
|
|
|
|
*/
|
2012-08-13 04:14:57 -06:00
|
|
|
static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
|
2012-07-31 08:21:20 -06:00
|
|
|
unsigned int *n)
|
2011-11-21 09:47:08 -07:00
|
|
|
{
|
2012-08-13 04:14:57 -06:00
|
|
|
struct gfs2_rbm pos = { .rgd = rbm->rgd, };
|
2011-11-21 09:47:08 -07:00
|
|
|
const unsigned int elen = *n;
|
2012-08-13 04:14:57 -06:00
|
|
|
u64 block;
|
|
|
|
int ret;
|
2011-11-21 09:47:08 -07:00
|
|
|
|
2012-08-13 04:14:57 -06:00
|
|
|
*n = 1;
|
|
|
|
block = gfs2_rbm_to_block(rbm);
|
2013-09-17 11:12:15 -06:00
|
|
|
gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
|
2012-08-13 04:37:51 -06:00
|
|
|
gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
|
2012-08-13 04:14:57 -06:00
|
|
|
block++;
|
2009-05-21 05:23:12 -06:00
|
|
|
while (*n < elen) {
|
2012-08-13 04:14:57 -06:00
|
|
|
ret = gfs2_rbm_from_block(&pos, block);
|
2018-08-07 09:07:00 -06:00
|
|
|
if (ret || gfs2_testbit(&pos, true) != GFS2_BLKST_FREE)
|
2009-05-21 05:23:12 -06:00
|
|
|
break;
|
2013-09-17 11:12:15 -06:00
|
|
|
gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
|
2012-08-13 04:37:51 -06:00
|
|
|
gfs2_setbit(&pos, true, GFS2_BLKST_USED);
|
2009-05-21 05:23:12 -06:00
|
|
|
(*n)++;
|
2012-08-13 04:14:57 -06:00
|
|
|
block++;
|
2007-06-08 03:05:33 -06:00
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rgblk_free - Change alloc state of given block(s)
|
|
|
|
* @sdp: the filesystem
|
2018-10-04 08:36:02 -06:00
|
|
|
* @rgd: the resource group the blocks are in
|
2006-01-16 09:50:04 -07:00
|
|
|
* @bstart: the start of a run of blocks to free
|
|
|
|
* @blen: the length of the block run (all must lie within ONE RG!)
|
|
|
|
* @new_state: GFS2_BLKST_XXX the after-allocation block state
|
|
|
|
*/
|
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
static void rgblk_free(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd,
|
|
|
|
u64 bstart, u32 blen, unsigned char new_state)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2012-08-03 04:23:28 -06:00
|
|
|
struct gfs2_rbm rbm;
|
2014-10-03 06:38:06 -06:00
|
|
|
struct gfs2_bitmap *bi, *bi_prev = NULL;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
rbm.rgd = rgd;
|
2018-09-10 10:31:47 -06:00
|
|
|
if (WARN_ON_ONCE(gfs2_rbm_from_block(&rbm, bstart)))
|
2018-10-04 08:36:02 -06:00
|
|
|
return;
|
2006-01-16 09:50:04 -07:00
|
|
|
while (blen--) {
|
2013-09-17 11:12:15 -06:00
|
|
|
bi = rbm_bi(&rbm);
|
2014-10-03 06:38:06 -06:00
|
|
|
if (bi != bi_prev) {
|
|
|
|
if (!bi->bi_clone) {
|
|
|
|
bi->bi_clone = kmalloc(bi->bi_bh->b_size,
|
|
|
|
GFP_NOFS | __GFP_NOFAIL);
|
|
|
|
memcpy(bi->bi_clone + bi->bi_offset,
|
|
|
|
bi->bi_bh->b_data + bi->bi_offset,
|
2018-09-26 16:32:46 -06:00
|
|
|
bi->bi_bytes);
|
2014-10-03 06:38:06 -06:00
|
|
|
}
|
|
|
|
gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
|
|
|
|
bi_prev = bi;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
2012-08-13 04:37:51 -06:00
|
|
|
gfs2_setbit(&rbm, false, new_state);
|
2014-10-03 06:38:06 -06:00
|
|
|
gfs2_rbm_incr(&rbm);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-05-20 03:48:47 -06:00
|
|
|
* gfs2_rgrp_dump - print out an rgrp
|
|
|
|
* @seq: The iterator
|
|
|
|
* @gl: The glock in question
|
2019-05-09 08:21:48 -06:00
|
|
|
* @fs_id_buf: pointer to file system id (if requested)
|
2009-05-20 03:48:47 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2019-05-09 08:21:48 -06:00
|
|
|
void gfs2_rgrp_dump(struct seq_file *seq, struct gfs2_glock *gl,
|
|
|
|
const char *fs_id_buf)
|
2009-05-20 03:48:47 -06:00
|
|
|
{
|
2012-07-19 06:12:40 -06:00
|
|
|
struct gfs2_rgrpd *rgd = gl->gl_object;
|
|
|
|
struct gfs2_blkreserv *trs;
|
|
|
|
const struct rb_node *n;
|
|
|
|
|
2009-05-20 03:48:47 -06:00
|
|
|
if (rgd == NULL)
|
2014-01-16 03:31:13 -07:00
|
|
|
return;
|
2019-05-09 08:21:48 -06:00
|
|
|
gfs2_print_dbg(seq, "%s R: n:%llu f:%02x b:%u/%u i:%u r:%u e:%u\n",
|
|
|
|
fs_id_buf,
|
2009-05-20 03:48:47 -06:00
|
|
|
(unsigned long long)rgd->rd_addr, rgd->rd_flags,
|
2012-07-19 06:12:40 -06:00
|
|
|
rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
|
2013-11-25 04:16:25 -07:00
|
|
|
rgd->rd_reserved, rgd->rd_extfail_pt);
|
2018-08-15 11:09:49 -06:00
|
|
|
if (rgd->rd_sbd->sd_args.ar_rgrplvb) {
|
|
|
|
struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
|
|
|
|
|
2019-05-09 08:21:48 -06:00
|
|
|
gfs2_print_dbg(seq, "%s L: f:%02x b:%u i:%u\n", fs_id_buf,
|
2018-08-15 11:09:49 -06:00
|
|
|
be32_to_cpu(rgl->rl_flags),
|
|
|
|
be32_to_cpu(rgl->rl_free),
|
|
|
|
be32_to_cpu(rgl->rl_dinodes));
|
|
|
|
}
|
2012-07-19 06:12:40 -06:00
|
|
|
spin_lock(&rgd->rd_rsspin);
|
|
|
|
for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
|
|
|
|
trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
|
2019-05-09 08:21:48 -06:00
|
|
|
dump_rs(seq, trs, fs_id_buf);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
spin_unlock(&rgd->rd_rsspin);
|
2009-05-20 03:48:47 -06:00
|
|
|
}
|
|
|
|
|
2009-07-31 09:19:40 -06:00
|
|
|
static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
2019-05-09 08:21:48 -06:00
|
|
|
char fs_id_buf[GFS2_FSNAME_LEN + 3 * sizeof(int) + 2];
|
|
|
|
|
2009-07-31 09:19:40 -06:00
|
|
|
fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
|
2009-09-14 02:50:57 -06:00
|
|
|
(unsigned long long)rgd->rd_addr);
|
2009-07-31 09:19:40 -06:00
|
|
|
fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
|
2019-05-09 08:21:48 -06:00
|
|
|
sprintf(fs_id_buf, "fsid=%s: ", sdp->sd_fsname);
|
|
|
|
gfs2_rgrp_dump(NULL, rgd->rd_gl, fs_id_buf);
|
2009-07-31 09:19:40 -06:00
|
|
|
rgd->rd_flags |= GFS2_RDF_ERROR;
|
|
|
|
}
|
|
|
|
|
2012-07-19 06:12:40 -06:00
|
|
|
/**
|
2012-08-01 13:35:05 -06:00
|
|
|
* gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
|
|
|
|
* @ip: The inode we have just allocated blocks for
|
|
|
|
* @rbm: The start of the allocated blocks
|
|
|
|
* @len: The extent length
|
2012-07-19 06:12:40 -06:00
|
|
|
*
|
2012-08-01 13:35:05 -06:00
|
|
|
* Adjusts a reservation after an allocation has taken place. If the
|
|
|
|
* reservation does not match the allocation, or if it is now empty
|
|
|
|
* then it is removed.
|
2012-07-19 06:12:40 -06:00
|
|
|
*/
|
2012-08-01 13:35:05 -06:00
|
|
|
|
|
|
|
static void gfs2_adjust_reservation(struct gfs2_inode *ip,
|
|
|
|
const struct gfs2_rbm *rbm, unsigned len)
|
2012-07-19 06:12:40 -06:00
|
|
|
{
|
2015-07-16 07:28:04 -06:00
|
|
|
struct gfs2_blkreserv *rs = &ip->i_res;
|
2012-08-01 13:35:05 -06:00
|
|
|
struct gfs2_rgrpd *rgd = rbm->rgd;
|
|
|
|
unsigned rlen;
|
|
|
|
u64 block;
|
|
|
|
int ret;
|
2012-07-19 06:12:40 -06:00
|
|
|
|
2012-08-01 13:35:05 -06:00
|
|
|
spin_lock(&rgd->rd_rsspin);
|
|
|
|
if (gfs2_rs_active(rs)) {
|
|
|
|
if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
|
|
|
|
block = gfs2_rbm_to_block(rbm);
|
|
|
|
ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
|
|
|
|
rlen = min(rs->rs_free, len);
|
|
|
|
rs->rs_free -= rlen;
|
|
|
|
rgd->rd_reserved -= rlen;
|
2012-08-23 08:37:59 -06:00
|
|
|
trace_gfs2_rs(rs, TRACE_RS_CLAIM);
|
2012-08-01 13:35:05 -06:00
|
|
|
if (rs->rs_free && !ret)
|
|
|
|
goto out;
|
2014-10-29 07:02:30 -06:00
|
|
|
/* We used up our block reservation, so we should
|
|
|
|
reserve more blocks next time. */
|
2018-08-30 09:01:50 -06:00
|
|
|
atomic_add(RGRP_RSRV_ADDBLKS, &ip->i_sizehint);
|
2012-08-01 13:35:05 -06:00
|
|
|
}
|
2013-03-13 08:26:38 -06:00
|
|
|
__rs_deltree(rs);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
2012-08-01 13:35:05 -06:00
|
|
|
out:
|
|
|
|
spin_unlock(&rgd->rd_rsspin);
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
|
|
|
|
2013-10-02 07:42:45 -06:00
|
|
|
/**
|
|
|
|
* gfs2_set_alloc_start - Set starting point for block allocation
|
|
|
|
* @rbm: The rbm which will be set to the required location
|
|
|
|
* @ip: The gfs2 inode
|
|
|
|
* @dinode: Flag to say if allocation includes a new inode
|
|
|
|
*
|
|
|
|
* This sets the starting point from the reservation if one is active
|
|
|
|
* otherwise it falls back to guessing a start point based on the
|
|
|
|
* inode's goal block or the last allocation point in the rgrp.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void gfs2_set_alloc_start(struct gfs2_rbm *rbm,
|
|
|
|
const struct gfs2_inode *ip, bool dinode)
|
|
|
|
{
|
|
|
|
u64 goal;
|
|
|
|
|
2015-07-16 07:28:04 -06:00
|
|
|
if (gfs2_rs_active(&ip->i_res)) {
|
|
|
|
*rbm = ip->i_res.rs_rbm;
|
2013-10-02 07:42:45 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
|
|
|
|
goal = ip->i_goal;
|
|
|
|
else
|
|
|
|
goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;
|
|
|
|
|
2018-09-10 10:31:47 -06:00
|
|
|
if (WARN_ON_ONCE(gfs2_rbm_from_block(rbm, goal))) {
|
|
|
|
rbm->bii = 0;
|
|
|
|
rbm->offset = 0;
|
|
|
|
}
|
2013-10-02 07:42:45 -06:00
|
|
|
}
|
|
|
|
|
2009-05-20 03:48:47 -06:00
|
|
|
/**
|
2011-11-18 08:58:32 -07:00
|
|
|
* gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
|
2008-02-01 07:52:30 -07:00
|
|
|
* @ip: the inode to allocate the block for
|
2009-05-20 03:48:47 -06:00
|
|
|
* @bn: Used to return the starting block number
|
2012-07-19 06:12:40 -06:00
|
|
|
* @nblocks: requested number of blocks/extent length (value/result)
|
2011-11-18 08:58:32 -07:00
|
|
|
* @dinode: 1 if we're allocating a dinode block, else 0
|
2011-11-14 09:17:08 -07:00
|
|
|
* @generation: the generation number of the inode
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
2009-05-20 03:48:47 -06:00
|
|
|
* Returns: 0 or error
|
2006-01-16 09:50:04 -07:00
|
|
|
*/
|
|
|
|
|
2011-11-22 05:18:51 -07:00
|
|
|
int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
|
2011-11-18 08:58:32 -07:00
|
|
|
bool dinode, u64 *generation)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2009-04-23 01:59:41 -06:00
|
|
|
struct buffer_head *dibh;
|
2018-06-21 06:42:37 -06:00
|
|
|
struct gfs2_rbm rbm = { .rgd = ip->i_res.rs_rbm.rgd, };
|
2011-11-22 05:18:51 -07:00
|
|
|
unsigned int ndata;
|
2011-11-14 09:17:08 -07:00
|
|
|
u64 block; /* block, within the file system scope */
|
2009-04-23 01:59:41 -06:00
|
|
|
int error;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2013-10-02 07:42:45 -06:00
|
|
|
gfs2_set_alloc_start(&rbm, ip, dinode);
|
2016-05-02 08:42:49 -06:00
|
|
|
error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, ip, false);
|
2012-07-30 04:06:08 -06:00
|
|
|
|
2012-08-23 06:43:40 -06:00
|
|
|
if (error == -ENOSPC) {
|
2013-10-02 07:42:45 -06:00
|
|
|
gfs2_set_alloc_start(&rbm, ip, dinode);
|
2016-05-02 08:42:49 -06:00
|
|
|
error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, NULL, false);
|
2012-08-23 06:43:40 -06:00
|
|
|
}
|
|
|
|
|
2012-07-30 04:06:08 -06:00
|
|
|
/* Since all blocks are reserved in advance, this shouldn't happen */
|
2012-08-01 13:35:05 -06:00
|
|
|
if (error) {
|
2013-11-25 04:16:25 -07:00
|
|
|
fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d fail_pt=%d\n",
|
2012-08-23 08:37:59 -06:00
|
|
|
(unsigned long long)ip->i_no_addr, error, *nblocks,
|
2013-11-25 04:16:25 -07:00
|
|
|
test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags),
|
|
|
|
rbm.rgd->rd_extfail_pt);
|
2012-07-30 04:06:08 -06:00
|
|
|
goto rgrp_error;
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
2012-07-30 04:06:08 -06:00
|
|
|
|
2012-08-13 04:14:57 -06:00
|
|
|
gfs2_alloc_extent(&rbm, dinode, nblocks);
|
|
|
|
block = gfs2_rbm_to_block(&rbm);
|
2012-08-25 11:21:47 -06:00
|
|
|
rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
|
2015-07-16 07:28:04 -06:00
|
|
|
if (gfs2_rs_active(&ip->i_res))
|
2012-08-01 13:35:05 -06:00
|
|
|
gfs2_adjust_reservation(ip, &rbm, *nblocks);
|
2011-11-22 05:18:51 -07:00
|
|
|
ndata = *nblocks;
|
|
|
|
if (dinode)
|
|
|
|
ndata--;
|
2011-11-21 09:47:08 -07:00
|
|
|
|
2011-11-14 09:17:08 -07:00
|
|
|
if (!dinode) {
|
2011-11-22 05:18:51 -07:00
|
|
|
ip->i_goal = block + ndata - 1;
|
2011-11-14 09:17:08 -07:00
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error == 0) {
|
|
|
|
struct gfs2_dinode *di =
|
|
|
|
(struct gfs2_dinode *)dibh->b_data;
|
2012-12-14 05:36:02 -07:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, dibh);
|
2011-11-14 09:17:08 -07:00
|
|
|
di->di_goal_meta = di->di_goal_data =
|
|
|
|
cpu_to_be64(ip->i_goal);
|
|
|
|
brelse(dibh);
|
|
|
|
}
|
2009-04-23 01:59:41 -06:00
|
|
|
}
|
2012-07-31 08:21:20 -06:00
|
|
|
if (rbm.rgd->rd_free < *nblocks) {
|
2018-10-03 07:47:36 -06:00
|
|
|
fs_warn(sdp, "nblocks=%u\n", *nblocks);
|
2009-05-20 03:48:47 -06:00
|
|
|
goto rgrp_error;
|
2012-07-19 06:12:40 -06:00
|
|
|
}
|
2009-05-20 03:48:47 -06:00
|
|
|
|
2012-07-31 08:21:20 -06:00
|
|
|
rbm.rgd->rd_free -= *nblocks;
|
2011-11-14 09:17:08 -07:00
|
|
|
if (dinode) {
|
2012-07-31 08:21:20 -06:00
|
|
|
rbm.rgd->rd_dinodes++;
|
|
|
|
*generation = rbm.rgd->rd_igeneration++;
|
2011-11-14 09:17:08 -07:00
|
|
|
if (*generation == 0)
|
2012-07-31 08:21:20 -06:00
|
|
|
*generation = rbm.rgd->rd_igeneration++;
|
2011-11-14 09:17:08 -07:00
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2012-12-14 05:36:02 -07:00
|
|
|
gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
|
2012-07-31 08:21:20 -06:00
|
|
|
gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2011-11-22 05:18:51 -07:00
|
|
|
gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
|
2011-11-14 09:17:08 -07:00
|
|
|
if (dinode)
|
2019-04-05 05:18:23 -06:00
|
|
|
gfs2_trans_remove_revoke(sdp, block, *nblocks);
|
2011-11-22 05:18:51 -07:00
|
|
|
|
2013-02-26 09:15:20 -07:00
|
|
|
gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2012-07-31 08:21:20 -06:00
|
|
|
rbm.rgd->rd_free_clone -= *nblocks;
|
|
|
|
trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
|
2011-11-18 08:58:32 -07:00
|
|
|
dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
|
2009-07-31 09:19:40 -06:00
|
|
|
*bn = block;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rgrp_error:
|
2012-07-31 08:21:20 -06:00
|
|
|
gfs2_rgrp_error(rbm.rgd);
|
2009-07-31 09:19:40 -06:00
|
|
|
return -EIO;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-23 09:39:34 -06:00
|
|
|
* __gfs2_free_blocks - free a contiguous run of block(s)
|
2006-01-16 09:50:04 -07:00
|
|
|
* @ip: the inode these blocks are being freed from
|
2018-10-04 08:36:02 -06:00
|
|
|
* @rgd: the resource group the blocks are in
|
2006-01-16 09:50:04 -07:00
|
|
|
* @bstart: first block of a run of contiguous blocks
|
|
|
|
* @blen: the length of the block run
|
2011-06-23 09:39:34 -06:00
|
|
|
* @meta: 1 if the blocks represent metadata
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
void __gfs2_free_blocks(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
|
|
|
|
u64 bstart, u32 blen, int meta)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
rgblk_free(sdp, rgd, bstart, blen, GFS2_BLKST_FREE);
|
2012-05-09 10:11:35 -06:00
|
|
|
trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
|
2008-11-04 03:25:13 -07:00
|
|
|
rgd->rd_free += blen;
|
2012-02-08 05:58:32 -07:00
|
|
|
rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
|
2012-12-14 05:36:02 -07:00
|
|
|
gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
|
2008-01-28 17:38:07 -07:00
|
|
|
gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2011-05-21 07:05:58 -06:00
|
|
|
/* Directories keep their data in the metadata address space */
|
2011-06-23 09:39:34 -06:00
|
|
|
if (meta || ip->i_depth)
|
2011-05-21 07:05:58 -06:00
|
|
|
gfs2_meta_wipe(ip, bstart, blen);
|
2011-02-23 14:11:33 -07:00
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2011-02-23 14:11:33 -07:00
|
|
|
/**
|
|
|
|
* gfs2_free_meta - free a contiguous run of data block(s)
|
|
|
|
* @ip: the inode these blocks are being freed from
|
2018-10-04 08:36:02 -06:00
|
|
|
* @rgd: the resource group the blocks are in
|
2011-02-23 14:11:33 -07:00
|
|
|
* @bstart: first block of a run of contiguous blocks
|
|
|
|
* @blen: the length of the block run
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
void gfs2_free_meta(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
|
|
|
|
u64 bstart, u32 blen)
|
2011-02-23 14:11:33 -07:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
__gfs2_free_blocks(ip, rgd, bstart, blen, 1);
|
2006-01-16 09:50:04 -07:00
|
|
|
gfs2_statfs_change(sdp, 0, +blen, 0);
|
2006-11-01 11:23:29 -07:00
|
|
|
gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2006-06-14 13:32:57 -06:00
|
|
|
void gfs2_unlink_di(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
struct gfs2_rgrpd *rgd;
|
2007-05-15 08:37:50 -06:00
|
|
|
u64 blkno = ip->i_no_addr;
|
2006-06-14 13:32:57 -06:00
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
rgd = gfs2_blk2rgrpd(sdp, blkno, true);
|
2006-06-14 13:32:57 -06:00
|
|
|
if (!rgd)
|
|
|
|
return;
|
2018-10-04 08:36:02 -06:00
|
|
|
rgblk_free(sdp, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
|
2012-05-09 10:11:35 -06:00
|
|
|
trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
|
2012-12-14 05:36:02 -07:00
|
|
|
gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
|
2008-01-28 17:38:07 -07:00
|
|
|
gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
|
2018-08-08 08:53:30 -06:00
|
|
|
be32_add_cpu(&rgd->rd_rgl->rl_unlinked, 1);
|
2006-06-14 13:32:57 -06:00
|
|
|
}
|
|
|
|
|
2017-11-22 08:24:14 -07:00
|
|
|
void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
|
|
|
|
2018-10-04 08:36:02 -06:00
|
|
|
rgblk_free(sdp, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
|
2008-11-04 03:32:57 -07:00
|
|
|
if (!rgd->rd_dinodes)
|
2006-01-16 09:50:04 -07:00
|
|
|
gfs2_consist_rgrpd(rgd);
|
2008-11-04 03:32:57 -07:00
|
|
|
rgd->rd_dinodes--;
|
2008-11-04 03:25:13 -07:00
|
|
|
rgd->rd_free++;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2012-12-14 05:36:02 -07:00
|
|
|
gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
|
2008-01-28 17:38:07 -07:00
|
|
|
gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
|
2018-08-08 08:53:30 -06:00
|
|
|
be32_add_cpu(&rgd->rd_rgl->rl_unlinked, -1);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
gfs2_statfs_change(sdp, 0, +1, -1);
|
2012-05-09 10:11:35 -06:00
|
|
|
trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
|
2006-11-01 11:23:29 -07:00
|
|
|
gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
|
2007-05-15 08:37:50 -06:00
|
|
|
gfs2_meta_wipe(ip, ip->i_no_addr, 1);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2009-09-08 11:00:30 -06:00
|
|
|
/**
|
|
|
|
* gfs2_check_blk_type - Check the type of a block
|
|
|
|
* @sdp: The superblock
|
|
|
|
* @no_addr: The block number to check
|
|
|
|
* @type: The block type we are looking for
|
|
|
|
*
|
|
|
|
* Returns: 0 if the block type matches the expected type
|
|
|
|
* -ESTALE if it doesn't match
|
|
|
|
* or -ve errno if something went wrong while checking
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
|
|
|
|
{
|
|
|
|
struct gfs2_rgrpd *rgd;
|
2011-08-31 09:38:29 -06:00
|
|
|
struct gfs2_holder rgd_gh;
|
2018-08-07 09:07:00 -06:00
|
|
|
struct gfs2_rbm rbm;
|
2012-03-05 08:19:35 -07:00
|
|
|
int error = -EINVAL;
|
2009-09-08 11:00:30 -06:00
|
|
|
|
2012-02-08 05:58:32 -07:00
|
|
|
rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
|
2009-09-08 11:00:30 -06:00
|
|
|
if (!rgd)
|
2011-08-31 09:38:29 -06:00
|
|
|
goto fail;
|
2009-09-08 11:00:30 -06:00
|
|
|
|
|
|
|
error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
|
|
|
|
if (error)
|
2011-08-31 09:38:29 -06:00
|
|
|
goto fail;
|
2009-09-08 11:00:30 -06:00
|
|
|
|
2018-08-07 09:07:00 -06:00
|
|
|
rbm.rgd = rgd;
|
|
|
|
error = gfs2_rbm_from_block(&rbm, no_addr);
|
2018-09-10 10:31:47 -06:00
|
|
|
if (WARN_ON_ONCE(error))
|
|
|
|
goto fail;
|
2018-08-07 09:07:00 -06:00
|
|
|
|
|
|
|
if (gfs2_testbit(&rbm, false) != type)
|
2009-09-08 11:00:30 -06:00
|
|
|
error = -ESTALE;
|
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&rgd_gh);
|
|
|
|
fail:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
|
|
|
* gfs2_rlist_add - add a RG to a list of RGs
|
2011-09-02 09:08:09 -06:00
|
|
|
* @ip: the inode
|
2006-01-16 09:50:04 -07:00
|
|
|
* @rlist: the list of resource groups
|
|
|
|
* @block: the block
|
|
|
|
*
|
|
|
|
* Figure out what RG a block belongs to and add that RG to the list
|
|
|
|
*
|
|
|
|
* FIXME: Don't use NOFAIL
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-09-02 09:08:09 -06:00
|
|
|
void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
|
2006-09-04 10:49:07 -06:00
|
|
|
u64 block)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2011-09-02 09:08:09 -06:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-01-16 09:50:04 -07:00
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
struct gfs2_rgrpd **tmp;
|
|
|
|
unsigned int new_space;
|
|
|
|
unsigned int x;
|
|
|
|
|
|
|
|
if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
|
|
|
|
return;
|
|
|
|
|
2018-06-21 06:22:12 -06:00
|
|
|
/*
|
|
|
|
* The resource group last accessed is kept in the last position.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (rlist->rl_rgrps) {
|
|
|
|
rgd = rlist->rl_rgd[rlist->rl_rgrps - 1];
|
|
|
|
if (rgrp_contains_block(rgd, block))
|
|
|
|
return;
|
2012-02-08 05:58:32 -07:00
|
|
|
rgd = gfs2_blk2rgrpd(sdp, block, 1);
|
2018-06-21 06:22:12 -06:00
|
|
|
} else {
|
2018-06-21 06:42:37 -06:00
|
|
|
rgd = ip->i_res.rs_rbm.rgd;
|
2018-06-21 06:22:12 -06:00
|
|
|
if (!rgd || !rgrp_contains_block(rgd, block))
|
|
|
|
rgd = gfs2_blk2rgrpd(sdp, block, 1);
|
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
if (!rgd) {
|
2018-06-21 06:22:12 -06:00
|
|
|
fs_err(sdp, "rlist_add: no rgrp for block %llu\n",
|
|
|
|
(unsigned long long)block);
|
2006-01-16 09:50:04 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-06-21 06:22:12 -06:00
|
|
|
for (x = 0; x < rlist->rl_rgrps; x++) {
|
|
|
|
if (rlist->rl_rgd[x] == rgd) {
|
|
|
|
swap(rlist->rl_rgd[x],
|
|
|
|
rlist->rl_rgd[rlist->rl_rgrps - 1]);
|
2006-01-16 09:50:04 -07:00
|
|
|
return;
|
2018-06-21 06:22:12 -06:00
|
|
|
}
|
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
if (rlist->rl_rgrps == rlist->rl_space) {
|
|
|
|
new_space = rlist->rl_space + 10;
|
|
|
|
|
|
|
|
tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
|
2006-07-27 12:29:00 -06:00
|
|
|
GFP_NOFS | __GFP_NOFAIL);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
if (rlist->rl_rgd) {
|
|
|
|
memcpy(tmp, rlist->rl_rgd,
|
|
|
|
rlist->rl_space * sizeof(struct gfs2_rgrpd *));
|
|
|
|
kfree(rlist->rl_rgd);
|
|
|
|
}
|
|
|
|
|
|
|
|
rlist->rl_space = new_space;
|
|
|
|
rlist->rl_rgd = tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
|
|
|
|
* and initialize an array of glock holders for them
|
|
|
|
* @rlist: the list of resource groups
|
|
|
|
*
|
|
|
|
* FIXME: Don't use NOFAIL
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-10-03 17:06:23 -06:00
|
|
|
void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
|
|
|
unsigned int x;
|
|
|
|
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 14:55:00 -06:00
|
|
|
rlist->rl_ghs = kmalloc_array(rlist->rl_rgrps,
|
|
|
|
sizeof(struct gfs2_holder),
|
|
|
|
GFP_NOFS | __GFP_NOFAIL);
|
2006-01-16 09:50:04 -07:00
|
|
|
for (x = 0; x < rlist->rl_rgrps; x++)
|
|
|
|
gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
|
2018-10-03 17:06:23 -06:00
|
|
|
LM_ST_EXCLUSIVE, 0,
|
2006-01-16 09:50:04 -07:00
|
|
|
&rlist->rl_ghs[x]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_rlist_free - free a resource group list
|
2014-07-02 14:05:27 -06:00
|
|
|
* @rlist: the list of resource groups
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
|
|
|
|
{
|
|
|
|
unsigned int x;
|
|
|
|
|
|
|
|
kfree(rlist->rl_rgd);
|
|
|
|
|
|
|
|
if (rlist->rl_ghs) {
|
|
|
|
for (x = 0; x < rlist->rl_rgrps; x++)
|
|
|
|
gfs2_holder_uninit(&rlist->rl_ghs[x]);
|
|
|
|
kfree(rlist->rl_ghs);
|
2012-07-19 06:12:40 -06:00
|
|
|
rlist->rl_ghs = NULL;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|