gmane.linux.cluster.redhat.cluster.devel

Re: [PATCH] libgfs2: Use flags for versions in metadata description

Steven Whitehouse — 2012-05-25T15:37:05

Hi,

Looks good to me,

Steve.

On Fri, 2012-05-25 at 16:05 +0100, Andrew Price wrote:

[PATCH] libgfs2: Use flags for versions in metadatadescription

Andrew Price — 2012-05-25T15:05:28

Consolidate the .gfs1 and .gfs2 fields into one .versions field and add
constants so we can test lgfs2_metadata versions more easily.

Signed-off-by: Andrew Price <anprice< at >redhat.com>
---
 gfs2/edit/hexedit.c    |    8 +++---
 gfs2/libgfs2/libgfs2.h |    5 ++-
 gfs2/libgfs2/meta.c    |   67 ++++++++++++++++++++----------------------------
 3 files changed, 35 insertions(+), 45 deletions(-)

diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index b4e6d15..2ff1125 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
< at >< at > -813,14 +813,13 < at >< at > int display_block_type(int from_restore)
 return ret_type;
 }
 
-static const struct lgfs2_metadata *find_mtype(uint32_t mtype, int gfs1)
+static const struct lgfs2_metadata *find_mtype(uint32_t mtype, const unsigned versions)
 {
 const struct lgfs2_metadata *m = lgfs2_metadata;
 unsigned n = 0;
 
 do {
-if (((gfs1 && m[n].gfs1) || (!gfs1 && m[n].gfs2))
-                         && m[n].mh_type == mtype)
+if ((m[n].versions & versions) && m[n].mh_type == m

Re: [PATCH 2/3] gfs2_edit: Fix find_mtype and support gfs1 structures

Steven Whitehouse — 2012-05-25T10:40:07

Hi,

On Fri, 2012-05-25 at 11:27 +0100, Andrew Price wrote:
I think that makes sense. I don't remember now why I did that with a
bitfield and not flags, but it is probably better to convert it to
flags. We'll want to give them a longer name though, as everything in
the library will land up with a LGFS2_ or lgfs2_ prefix in the end,

Steve.

Re: [PATCH 2/3] gfs2_edit: Fix find_mtype and support gfs1 structures

Andrew Price — 2012-05-25T10:27:59

I'm wondering if we should represent the version metadata as flags 
instead of separate gfs1 and gfs2 fields and define some constants so we 
can do the comparison in one go, e.g.

                 if ((m[n].versions & versions) ...

Where versions is some combination of defined constants passed into the 
function like LGFS2_VER_1 | LGFS2_VER_2

But that has its own drawbacks I guess so I'm probably just splitting 
hairs. What do you think?

Andy

Re: [PATCH 3/3] gfs2_edit: Clean up some magic offsets

Steven Whitehouse — 2012-05-25T10:19:07

Hi,

Those all look ok to me,

Steve.

On Fri, 2012-05-25 at 11:07 +0100, Andrew Price wrote:

[PATCH 3/3] gfs2_edit: Clean up some magic offsets

Andrew Price — 2012-05-25T10:07:04

Replace some uses of magic offsets with equivalent struct member
accesses.

Signed-off-by: Andrew Price <anprice< at >redhat.com>
---
 gfs2/edit/hexedit.c |    9 +++++----
 1 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 8311534..b4e6d15 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
< at >< at > -838,6 +838,7 < at >< at > static int hexdump(uint64_t startaddr, int len)
 uint64_t l;
 const char *lpBuffer = bh->b_data;
 int print_field, cursor_line;
+const uint32_t block_type = get_block_type(bh);
 
 strcpy(edit_fmt,"%02x");
 pointer = (unsigned char *)lpBuffer + offset;
< at >< at > -935,7 +936,7 < at >< at > static int hexdump(uint64_t startaddr, int len)
 }
 print_gfs2("] ");
 if (print_field >= 0) {
-const struct lgfs2_metadata *m = find_mtype(get_block_type(bh), sbd.gfs1);
+const struct lgfs2_metadata *m = find_mtype(block_type, sbd.gfs1);
 if (m) {
 const struct lgfs2_metafield *f;
 unsigned n;
< at >< at > -951,9 +952,9 < at >< at > static int hexdump(uint64_t sta

[PATCH 2/3] gfs2_edit: Fix find_mtype and supportgfs1 structures

Andrew Price — 2012-05-25T10:07:03

Fixes up find_mtype to really iterate over the metadata array and to
choose between gfs2 and gfs1 structures.

Signed-off-by: Andrew Price <anprice< at >redhat.com>
---
 gfs2/edit/hexedit.c |    9 +++++----
 1 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 69d1940..8311534 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
< at >< at > -813,14 +813,15 < at >< at > int display_block_type(int from_restore)
 return ret_type;
 }
 
-static const struct lgfs2_metadata *find_mtype(uint32_t mtype)
+static const struct lgfs2_metadata *find_mtype(uint32_t mtype, int gfs1)
 {
 const struct lgfs2_metadata *m = lgfs2_metadata;
 unsigned n = 0;
 
 do {
-if (m->gfs2 && m->mh_type == mtype)
-return m;
+if (((gfs1 && m[n].gfs1) || (!gfs1 && m[n].gfs2))
+                         && m[n].mh_type == mtype)
+return &m[n];
 n++;
 } while (n < lgfs2_metadata_size);
 
< at >< at > -934,7 +935,7 < at >< at > static int hexdump(uint64_t startaddr, int len)
 }
 print_gfs2("] ");
 if (p

[PATCH 1/3] gfs2-utils: Remove references tounlinked file tag

Andrew Price — 2012-05-25T10:07:02

Remove references to an obsolete unlinked tag file (or file tag).

Signed-off-by: Andrew Price <anprice< at >redhat.com>
---
 gfs2/libgfs2/libgfs2.h |    1 -
 gfs2/man/gfs2_jadd.8   |    3 ---
 gfs2/man/mkfs.gfs2.8   |    3 ---
 gfs2/mkfs/main_mkfs.c  |    5 +----
 4 files changed, 1 insertions(+), 11 deletions(-)

diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index e2a7e45..8ed08dd 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
< at >< at > -255,7 +255,6 < at >< at > struct gfs2_sbd {
 unsigned int bsize;     /* The block size of the FS (in bytes) */
 unsigned int jsize;     /* Size of journals (in MB) */
 unsigned int rgsize;     /* Size of resource groups (in MB) */
-unsigned int utsize;     /* Size of unlinked tag files (in MB) */
 unsigned int qcsize;     /* Size of quota change files (in MB) */
 
 int debug;
diff --git a/gfs2/man/gfs2_jadd.8 b/gfs2/man/gfs2_jadd.8
index a645fb7..5453edd 100644
--- a/gfs2/man/gfs2_jadd.8
+++ b/gfs2/man/gfs2_jadd.8
< at >< at > -50,9 +50,6 < at >< at > The number of new jour

GFS2 git tree

Steven Whitehouse — 2012-05-22T10:28:10

Hi,

Linus has pulled all the patches for the merge window. Although I've got
a few patches queued up, I'll put them in at -rc1 as usual to avoid the
next window's patches getting tangled up with the current window. So the
tree is empty again for the time being,

Steve.

[PATCH] GFS2: Use lvbs for storing rgrp information

Benjamin Marzinski — 2012-05-22T05:25:39

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.

Signed-off-by: Benjamin Marzinski <bmarzins< at >redhat.com>
---
 fs/gfs2/glock.c             |    1 
 fs/gfs2/incore.h            |    1 
 fs/gfs2/rgrp.c              |  138 +++++++++++++++++++++++++++++++++++++++++---
 include/linux/gfs2_ondisk.h |   10 +++
 4 files changed, 141 insertions(+), 9 deletions(-)

Index: gfs2-3.0-nmw/fs/gfs2

Re: [patch] dlm: remove stray unlock

David Teigland — 2012-05-21T15:39:32

Thanks, will fix that.

[GFS2 Patch][TRY #3] GFS2: Fold quota data into thereservations struct

Bob Peterson — 2012-05-18T13:28:23

Hi,

I posted this patch earlier. The only thing that's changed is
the diff offsets, due to other patches that have gone in.

The question was previously asked: Does it matter that I removed
a bunch of calls to gfs2_qadata_get, which itself called function
gfs2_rindex_update? The answer is yes, it matters, and that's why
I've replaced some of the calls with calls directly to function
gfs2_rindex_update rather. Hopefully I've gotten all the places
that matter. Perhaps someone should check my work. :)

This patch moves the ancillary quota data structures into the
block reservations structure. This saves GFS2 some time and
effort in allocating and deallocating the qadata structure.

Regards,

Bob Peterson
Red Hat File Systems

Signed-off-by: Bob Peterson <rpeterso< at >redhat.com> 
---
diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index aba77b5..d652634 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
< at >< at > -614,7 +614,6 < at >< at > static int gfs2_write_begin(struct file *file, struct address_space *mapping,
 unsigned int data

[GFS2 Patch][TRY 4] GFS2: Extend the life of thereservations structure

Bob Peterson — 2012-05-18T11:00:36

Hi,

Sorry for the problems encountered on try #3 of this patch.
For Try #4, I've systematically gone through all the places where
a reservation is necessary, and made sure one was created.
I've also tested it with quotas enabled against postmark, fs_mark,
and iozone.

This patch lengthens the lifespan of the reservations structure for
inodes. Before, they were allocated and deallocated for every write
operation. With this patch, they are allocated when the first write
occurs, and deallocated when the last process closes the file.
It's more efficient to do it this way because it saves GFS2 a lot of
unnecessary allocates and frees. It also gives us more flexibility
for the future: (1) we can now fold the qadata structure back into
the structure and save those alloc/frees, (2) we can use this for
multi-block reservations.

Regards,

Bob Peterson
Red Hat File Systems

Signed-off-by: Bob Peterson <rpeterso< at >redhat.com> 
---
diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index e80a464..aba77b5 100644
--- a/fs/gfs2/a

[PATCH 12/24] GFS2: Remove bd_list_tr

Steven Whitehouse — 2012-05-17T12:23:19

This is another clean up in the logging code. This per-transaction
list was largely unused. Its main function was to ensure that the
number of buffers in a transaction was correct, however that counter
was only used to check the number of buffers in the bd_list_tr, plus
an assert at the end of each transaction. With the assert now changed
to use the calculated buffer counts, we can remove both bd_list_tr and
its associated counter.

This should make the code easier to understand as well as shrinking
a couple of structures.

Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index 56dc1f0..a627b3e 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
< at >< at > -1084,7 +1084,6 < at >< at > int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
 bd = bh->b_private;
 if (bd) {
 gfs2_assert_warn(sdp, bd->bd_bh == bh);
-gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
 if (!list_empty(&bd->bd_le.le_list)) {
 if (!buffer_pinned(bh))
 list_del_init(&bd->bd_le.le_

[PATCH 10/24] GFS2: Clean up log write code path

Steven Whitehouse — 2012-05-17T12:23:17

Prior to this patch, we have two ways of sending i/o to the log.
One of those is used when we need to allocate both the data
to be written itself and also a buffer head to submit it. This
is done via sb_getblk and friends. This is used mostly for writing
log headers.

The other method is used when writing blocks which have some
in-place counterpart. This is the case for all the metadata
blocks which are journalled, and when journaled data is in use,
for unescaped journalled data blocks.

This patch replaces both of those two methods, and about half
a dozen separate i/o submission points with a single i/o
submission function. We also go direct to bio rather than
using buffer heads, since this allows us to build i/o
requests of the maximum size for the block device in
question. It also reduces the memory required for flushing
the log, which can be very useful in low memory situations.

Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 47d0bda..dd97f6

[PATCH 17/24] GFS2: eliminate log elements andsimplify

Steven Whitehouse — 2012-05-17T12:23:24

From: Bob Peterson <rpeterso< at >redhat.com>

This patch eliminates the gfs2_log_element data structure and
rolls its two components into the gfs2_bufdata. This makes the code
easier to understand and makes it easier to migrate to a rbtree
to keep the list sorted.

Signed-off-by: Bob Peterson <rpeterso< at >redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index 695bbe1..e80a464 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
< at >< at > -942,8 +942,8 < at >< at > static void gfs2_discard(struct gfs2_sbd *sdp, struct buffer_head *bh)
 clear_buffer_dirty(bh);
 bd = bh->b_private;
 if (bd) {
-if (!list_empty(&bd->bd_le.le_list) && !buffer_pinned(bh))
-list_del_init(&bd->bd_le.le_list);
+if (!list_empty(&bd->bd_list) && !buffer_pinned(bh))
+list_del_init(&bd->bd_list);
 else
 gfs2_remove_from_journal(bh, current->journal_info, 0);
 }
< at >< at > -1083,9 +1083,9 < at >< at > int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
 bd = bh->b_private;
 if (bd) {
 gfs2_as

[PATCH 19/24] GFS2: Remove redundant metadata blocktype check

Steven Whitehouse — 2012-05-17T12:23:26

From: Bob Peterson <rpeterso< at >redhat.com>

This patch removes a redundant metadata block check. See description below.

Signed-off-by: Bob Peterson <rpeterso< at >redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index cd3e6fb..4bdcf37 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
< at >< at > -378,11 +378,6 < at >< at > int gfs2_inode_refresh(struct gfs2_inode *ip)
 if (error)
 return error;
 
-if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
-brelse(dibh);
-return -EIO;
-}
-
 error = gfs2_dinode_in(ip, dibh->b_data);
 brelse(dibh);
 clear_bit(GIF_INVALID, &ip->i_flags);

[PATCH 22/24] GFS2: Eliminate unused "new"parameter to gfs2_meta_indirect_buffer

Steven Whitehouse — 2012-05-17T12:23:29

From: Bob Peterson <rpeterso< at >redhat.com>

It turns out that the "new" parameter to function gfs2_meta_indirect_buffer
was always being passed in as zero. Therefore, this patch eliminates it
and simplifies the function.

Signed-off-by: Bob Peterson <rpeterso< at >redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index 420bbeb..dab5409 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
< at >< at > -324,7 +324,7 < at >< at > static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
 if (!dblock)
 return x + 1;
 
-ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, 0, &mp->mp_bh[x+1]);
+ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, &mp->mp_bh[x+1]);
 if (ret)
 return ret;
 }
< at >< at > -882,7 +882,7 < at >< at > static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh,
 top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];
 bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;
 } else {
-error =

[PATCH 20/24] GFS2: Update main gfs2 doc

Steven Whitehouse — 2012-05-17T12:23:27

Various items were a bit out of date, so this is a refresh to the
latest info.

Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/Documentation/filesystems/gfs2.txt b/Documentation/filesystems/gfs2.txt
index 4cda926..cc4f230 100644
--- a/Documentation/filesystems/gfs2.txt
+++ b/Documentation/filesystems/gfs2.txt
< at >< at > -1,7 +1,7 < at >< at >
 Global File System
 ------------------
 
-http://sources.redhat.com/cluster/wiki/
+https://fedorahosted.org/cluster/wiki/HomePage
 
 GFS is a cluster file system. It allows a cluster of computers to
 simultaneously use a block device that is shared between them (with FC,
< at >< at > -30,7 +30,8 < at >< at > needed, simply:
 
 If you are using Fedora, you need to install the gfs2-utils package
 and, for lock_dlm, you will also need to install the cman package
-and write a cluster.conf as per the documentation.
+and write a cluster.conf as per the documentation. For F17 and above
+cman has been replaced by the dlm package.
 
 GFS2 is not on-disk compatible with previous versions of GFS

[PATCH 09/24] GFS2: Use variable rather than qa todetermine if unstuff necessary

Steven Whitehouse — 2012-05-17T12:23:16

From: Bob Peterson <rpeterso< at >redhat.com>

In the future, the qadata structure will be eliminated and merged
back in with the block reservation structure, after we extend the
lifespan of that. This patch is a step forward in eliminating the
qadata structure. It adds a variable to the do_grow function to
determine when unstuffing is necessary, and has been done.

Signed-off-by: Bob Peterson <rpeterso< at >redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index 03c04fe..420bbeb 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
< at >< at > -1169,6 +1169,7 < at >< at > static int do_grow(struct inode *inode, u64 size)
 struct buffer_head *dibh;
 struct gfs2_qadata *qa = NULL;
 int error;
+int unstuff = 0;
 
 if (gfs2_is_stuffed(ip) &&
     (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {
< at >< at > -1183,13 +1184,14 < at >< at > static int do_grow(struct inode *inode, u64 size)
 error = gfs2_inplace_reserve(ip, 1);
 if (error)
 goto do_grow_qunlock;
+unstuff = 1;

[PATCH 13/24] GFS2: Remove unused argument fromgfs2_internal_read

Steven Whitehouse — 2012-05-17T12:23:20

From: Andrew Price <anprice< at >redhat.com>

gfs2_internal_read accepts an unused ra_state argument, left over from
when we did readahead on the rindex. Since there are currently no plans
to add back this readahead, this patch removes the ra_state parameter
and updates the functions which call gfs2_internal_read accordingly.

Signed-off-by: Andrew Price <anprice< at >redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index a627b3e..695bbe1 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
< at >< at > -517,15 +517,14 < at >< at > out:
 /**
  * gfs2_internal_read - read an internal file
  * < at >ip: The gfs2 inode
- * < at >ra_state: The readahead state (or NULL for no readahead)
  * < at >buf: The buffer to fill
  * < at >pos: The file position
  * < at >size: The amount to read
  *
  */
 
-int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
-                       char *buf, loff_t *pos, unsigned size)
+int gfs2_internal_read(struct gfs2_inode *ip, char *buf, loff_t *pos,
+