Pre-pull patch posting
Hi,
Here is the current GFS2 patch queue. You'll notice that this time there are no DLM patches in this list. That is because the DLM team are setting up their own git tree and this future DLM patches will be sent directly by them rather than via the GFS2 tree.
Most of this set of patches is clean up and bug fixes, there is really not a lot new this time. I guess the most significant thing is the patch to use ->page_mkwrite which will greatly increase efficiency when files opened r/w are mostly only accessed for reading across a cluster.
There are a number of cleanups related to journalling which is really where the largest number of changes in terms of code lines is. The indirect blocks for the journal are now scanned once only at mount time and the bmap information is retained in the form of an extent list. Since we expect journals to consist of only a single extent in the normal case, this should generally be quite a short list :-)
In addition some of the tunables relating to the journal have been removed in favour of autotuning those variables.
Steve.
PATCH 1/58 Handle multiple glock demote requests
From: Wendy Cheng <[email protected]>
Fix a race condition where multiple glock demote requests are sent to a node back-to-back. This patch does a check inside handle_callback() to see whether a demote request is in progress. If true, it sets a flag to make sure run_queue() will loop again to handle the new request, instead of erronously setting gl_demote_state to a different state.
fs/gfs2/glock.c +14 -1
@@ -567,7 +567,10 @@ static int rq_demote(struct gfs2_glock *gl)gfs2_demote_wake (gl);return 0 ; } +set_bit (GLF_LOCK , &gl->gl_flags); +set_bit (GLF_DEMOTE_IN_PROGRESS , &gl->gl_flags); +if (gl->gl_demote_state ==LM_ST_UNLOCKED || gl->gl_state !=LM_ST_EXCLUSIVE ) {spin_unlock (&gl->gl_spin);
@@ -576,7 +579,9 @@ static int rq_demote(struct gfs2_glock *gl)spin_unlock (&gl->gl_spin);gfs2_glock_xmote_th (gl,NULL ); } +spin_lock (&gl->gl_spin); +clear_bit (GLF_DEMOTE_IN_PROGRESS , &gl->gl_flags);return 0 ; }
@@ -606,6 +611,11 @@ static void run_queue(struct gfs2_glock *gl) }else if (test_bit (GLF_DEMOTE , &gl->gl_flags)) { blocked =rq_demote (gl); +if (gl->gl_waiters2 && !blocked) { +set_bit (GLF_DEMOTE , &gl->gl_flags); + gl->gl_demote_state =LM_ST_UNLOCKED ; + } + gl->gl_waiters2 =0 ; }else if (!list_empty (&gl->gl_waiters3)) { gh =list_entry (gl->gl_waiters3.next, struct gfs2_holder, gh_list);
@@ -722,7 +732,10 @@ static void handle_callback(struct gfs2_glock *gl, unsigned int state, } }else if (gl->gl_demote_state !=LM_ST_UNLOCKED && gl->gl_demote_state != state) { - gl->gl_demote_state =LM_ST_UNLOCKED ; +if (test_bit (GLF_DEMOTE_IN_PROGRESS , &gl->gl_flags)) + gl->gl_waiters2 =1 ; +else + gl->gl_demote_state =LM_ST_UNLOCKED ; }spin_unlock (&gl->gl_spin); }
fs/gfs2/incore.h +2 -0
@@ -171,6 +171,7 @@ enum {GLF_DEMOTE =3 ,GLF_PENDING_DEMOTE =4 ,GLF_DIRTY =5 , + GLF_DEMOTE_IN_PROGRESS = 6, }; struct gfs2_glock {
@@ -190,6 +191,7 @@ struct gfs2_glock {struct list_head gl_holders;struct list_head gl_waiters1;/* HIF_MUTEX */ struct list_head gl_waiters3;/* HIF_PROMOTE */ +int gl_waiters2;/* GIF_DEMOTE */ const struct gfs2_glock_operations *gl_ops;
Signature · 1 line
1.5.1.2
PATCH 2/58 Clean up internal read function
From: Steven Whitehouse <[email protected]>
As requested by Christoph, this patch cleans up GFS2's internal read function so that it no longer uses the do_generic_mapping_read function. This function is obsolete and GFS2 is the last user of it.
As a side effect the internal read code gets smaller and easier to read and gfs2_readpage is split into two. One function has the locking and the other function has the rest of the logic.
fs/gfs2/inode.c +0 -1
@@ -31,7 +31,6 @@#include "log.h" #include "meta_io.h" #include "ops_address.h" -#include "ops_file.h" #include "ops_inode.h" #include "quota.h" #include "rgrp.h"
fs/gfs2/ops_address.c +101 -50
197 lines not on this page · raw message
fs/gfs2/ops_address.h +3 -0
@@ -18,5 +18,8 @@ extern const struct address_space_operations gfs2_file_aops;extern int gfs2_get_block (struct inode *inode,sector_t lblock,struct buffer_head *bh_result,int create);extern int gfs2_releasepage (struct page *page,gfp_t gfp_mask); +extern int gfs2_internal_read (struct gfs2_inode *ip, +struct file_ra_state *ra_state, +char *buf,loff_t *pos,unsigned size);#endif /* __OPS_ADDRESS_DOT_H__ */
fs/gfs2/ops_file.c +0 -45
57 lines not on this page · raw message
fs/gfs2/ops_file.h deleted +0 -24
@@ -1,24 +0,0 @@ -/* -* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. -* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. -* -* This copyrighted material is made available to anyone wishing to use, -* modify, copy, or redistribute it subject to the terms and conditions -* of the GNU General Public License version 2. -*/ - -#ifndef __OPS_FILE_DOT_H__ -#define __OPS_FILE_DOT_H__ - -#include <linux/fs.h> -struct gfs2_inode ; - -extern struct file gfs2_internal_file_sentinel; -extern int gfs2_internal_read (struct gfs2_inode *ip, -struct file_ra_state *ra_state, -char *buf,loff_t *pos,unsigned size); -extern void gfs2_set_inode_flags (struct inode *inode); -extern const struct file_operations gfs2_file_fops; -extern const struct file_operations gfs2_dir_fops; - -#endif /* __OPS_FILE_DOT_H__ */
fs/gfs2/ops_inode.h +4 -0
@@ -16,5 +16,9 @@ extern const struct inode_operations gfs2_file_iops;extern const struct inode_operations gfs2_dir_iops;extern const struct inode_operations gfs2_symlink_iops;extern const struct inode_operations gfs2_dev_iops; +extern const struct file_operations gfs2_file_fops; +extern const struct file_operations gfs2_dir_fops; + +extern void gfs2_set_inode_flags (struct inode *inode);#endif /* __OPS_INODE_DOT_H__ */
fs/gfs2/quota.c +2 -5
@@ -59,7 +59,6 @@#include "super.h" #include "trans.h" #include "inode.h" -#include "ops_file.h" #include "ops_address.h" #include "util.h"
@@ -793,11 +792,9 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,struct gfs2_holder i_gh;struct gfs2_quota_host q;char buf[sizeof (struct gfs2_quota )]; -struct file_ra_state ra_state;int error;struct gfs2_quota_lvb *qlvb; -file_ra_state_init (&ra_state, sdp->sd_quota_inode->i_mapping); restart: error =gfs2_glock_nq_init (qd->qd_gl,LM_ST_SHARED ,0 , q_gh);if (error)
@@ -820,8 +817,8 @@ restart:memset (buf,0 ,sizeof (struct gfs2_quota )); pos =qd2offset (qd); - error =gfs2_internal_read (ip, &ra_state, buf, - &pos,sizeof (struct gfs2_quota )); + error =gfs2_internal_read (ip,NULL , buf, &pos, +sizeof (struct gfs2_quota ));if (error <0 ) goto fail_gunlock;
fs/gfs2/rgrp.c +1 -1
@@ -25,10 +25,10 @@#include "rgrp.h" #include "super.h" #include "trans.h" -#include "ops_file.h" #include "util.h" #include "log.h" #include "inode.h" +#include "ops_address.h" #define BFITNOENT ((u32)~0)#define NO_BLOCK ((u64)~0)
Signature · 1 line
1.5.1.2
PATCH 3/58 Use ->page_mkwrite() for mmap()
From: Steven Whitehouse <[email protected]>
This cleans up the mmap() code path for GFS2 by implementing the page_mkwrite function for GFS2. We are thus able to use the generic filemap_fault function for our ->fault() implementation.
This now means that shared writable mappings will be much more efficiently shared across the cluster if there is a reasonable proportion of read activity (the greater proportion, the better).
As a side effect, it also reduces the size of the code, removes special cases from readpage and readpages, and makes the code path easier to follow.
fs/gfs2/Makefile +1 -1
@@ -2,7 +2,7 @@ obj-$(CONFIG_GFS2_FS) += gfs2.o gfs2-y := acl.o bmap.o daemon.o dir.o eaops.o eattr.o glock.o \ glops.o inode.o lm.o log.o lops.o locking.o main.o meta_io.o \ mount.o ops_address.o ops_dentry.o ops_export.o ops_file.o \ - ops_fstype.o ops_inode.o ops_super.o ops_vm.o quota.o \ + ops_fstype.o ops_inode.o ops_super.o quota.o \ recovery.o rgrp.o super.o sys.o trans.o util.o obj-$(CONFIG_GFS2_FS_LOCKING_NOLOCK) += locking/nolock/
fs/gfs2/glops.c +1 -8
@@ -86,15 +86,10 @@ static void gfs2_pte_inval(struct gfs2_glock *gl)if (!ip || !S_ISREG (inode->i_mode))return ; -if (!test_bit (GIF_PAGED , &ip->i_flags)) -return ; -unmap_shared_mapping_range (inode->i_mapping,0 ,0 ); -if (test_bit (GIF_SW_PAGED , &ip->i_flags))set_bit (GLF_DIRTY , &gl->gl_flags); -clear_bit (GIF_SW_PAGED , &ip->i_flags); }/**
@@ -234,10 +229,8 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags)set_bit (GIF_INVALID , &ip->i_flags); } -if (ip &&S_ISREG (ip->i_inode.i_mode)) { +if (ip &&S_ISREG (ip->i_inode.i_mode))truncate_inode_pages (ip->i_inode.i_mapping,0 ); -clear_bit (GIF_PAGED , &ip->i_flags); - } }/**
fs/gfs2/incore.h +0 -8
@@ -241,7 +241,6 @@ struct gfs2_alloc {enum {GIF_INVALID =0 ,GIF_QD_LOCKED =1 , -GIF_PAGED =2 ,GIF_SW_PAGED =3 , };
@@ -289,19 +288,12 @@ static inline struct gfs2_inode *GFS2_I(struct inode *inode) return container_of(inode, struct gfs2_inode, i_inode); } -/* To be removed? */ static inline struct gfs2_sbd *GFS2_SB (struct inode *inode) {return inode->i_sb->s_fs_info; } -enum { -GFF_DID_DIRECT_ALLOC =0 , -GFF_EXLOCK =1 , -}; -struct gfs2_file { -unsigned long f_flags;/* GFF_... */ struct mutex f_fl_mutex;struct gfs2_holder f_fl_gh; };
fs/gfs2/ops_address.c +8 -37
78 lines not on this page · raw message
fs/gfs2/ops_file.c +121 -10
155 lines not on this page · raw message
fs/gfs2/ops_vm.c deleted +0 -169
169 lines not on this page · raw message
fs/gfs2/ops_vm.h deleted +0 -18
@@ -1,18 +0,0 @@ -/* -* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. -* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. -* -* This copyrighted material is made available to anyone wishing to use, -* modify, copy, or redistribute it subject to the terms and conditions -* of the GNU General Public License version 2. -*/ - -#ifndef __OPS_VM_DOT_H__ -#define __OPS_VM_DOT_H__ - -#include <linux/mm.h> - -extern struct vm_operations_struct gfs2_vm_ops_private; -extern struct vm_operations_struct gfs2_vm_ops_sharewrite; - -#endif /* __OPS_VM_DOT_H__ */
Signature · 1 line
1.5.1.2
PATCH 4/58 Remove useless i_cache from inodes
From: Steven Whitehouse <[email protected]>
The i_cache was designed to keep references to the indirect blocks used during block mapping so that they didn't have to be looked up continually. The idea failed because there are too many places where the i_cache needs to be freed, and this has in the past been the cause of many bugs.
In addition there was no performance benefit being gained since the disk blocks in question were cached anyway. So this patch removes it in order to simplify the code to prepare for other changes which would otherwise have had to add further support for this feature.
fs/gfs2/glops.c +1 -20
@@ -56,7 +56,7 @@ static void gfs2_ail_empty_gl(struct gfs2_glock *gl) bd = list_entry(head->next, struct gfs2_bufdata, bd_ail_gl_list); bh = bd->bd_bh; -gfs2_remove_from_ail (NULL , bd); +gfs2_remove_from_ail (bd); bd->bd_bh =NULL ; bh->b_private =NULL ; bd->bd_blkno = bh->b_blocknr;
@@ -287,23 +287,6 @@ static int inode_go_lock(struct gfs2_holder *gh) }/** -* inode_go_unlock - operation done before an inode lock is unlocked by a -* process -* @gl: the glock -* @flags: -* -*/ - -static void inode_go_unlock (struct gfs2_holder *gh) -{ -struct gfs2_glock *gl = gh->gh_gl; -struct gfs2_inode *ip = gl->gl_object; - -if (ip) -gfs2_meta_cache_flush (ip); -} - -/** * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock * @gl: the glock *
@@ -377,7 +360,6 @@ static void trans_go_xmote_bh(struct gfs2_glock *gl)if (gl->gl_state !=LM_ST_UNLOCKED &&test_bit (SDF_JOURNAL_LIVE , &sdp->sd_flags)) { -gfs2_meta_cache_flush (GFS2_I (sdp->sd_jdesc->jd_inode)); j_gl->gl_ops->go_inval (j_gl,DIO_METADATA ); error =gfs2_find_jhead (sdp->sd_jdesc, &head);
@@ -437,7 +419,6 @@ const struct gfs2_glock_operations gfs2_inode_glops = { .go_inval = inode_go_inval, .go_demote_ok = inode_go_demote_ok, .go_lock = inode_go_lock, - .go_unlock = inode_go_unlock, .go_type = LM_TYPE_INODE, .go_min_hold_time = HZ / 10, };
fs/gfs2/incore.h +0 -2
@@ -275,8 +275,6 @@ struct gfs2_inode {spinlock_t i_spin;struct rw_semaphore i_rw_mutex;unsigned long i_last_pfault; - -struct buffer_head *i_cache[GFS2_MAX_META_HEIGHT ]; };/*
fs/gfs2/inode.c +5 -8
@@ -293,11 +293,6 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)return 0 ; } -static void gfs2_inode_bh (struct gfs2_inode *ip,struct buffer_head *bh) -{ - ip->i_cache[0 ] = bh; -} -/** * gfs2_inode_refresh - Refresh the incore copy of the dinode * @ip: The GFS2 inode
@@ -965,7 +960,7 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,struct gfs2_inum_host inum = { .no_addr =0 , .no_formal_ino =0 };int error;u64 generation; -struct buffer_head *bh=NULL ; +struct buffer_head *bh =NULL ;if (!name->len || name->len >GFS2_FNAMESIZE )return ERR_PTR (-ENAMETOOLONG );
@@ -1002,8 +997,6 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,if (IS_ERR (inode)) goto fail_gunlock2; -gfs2_inode_bh (GFS2_I (inode), bh); - error =gfs2_inode_refresh (GFS2_I (inode));if (error) goto fail_gunlock2;
@@ -1020,6 +1013,8 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,if (error) goto fail_gunlock2; +if (bh) +brelse (bh);if (!inode)return ERR_PTR (-ENOMEM );return inode;
@@ -1031,6 +1026,8 @@ fail_gunlock2: fail_gunlock:gfs2_glock_dq (ghs); fail: +if (bh) +brelse (bh);return ERR_PTR (error); }
fs/gfs2/log.c +2 -4
@@ -68,14 +68,12 @@ unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,* */ -void gfs2_remove_from_ail (struct address_space *mapping,struct gfs2_bufdata *bd) +void gfs2_remove_from_ail (struct gfs2_bufdata *bd) { bd->bd_ail =NULL ;list_del_init (&bd->bd_ail_st_list);list_del_init (&bd->bd_ail_gl_list);atomic_dec (&bd->bd_gl->gl_ail_count); -if (mapping) -gfs2_meta_cache_flush (GFS2_I (mapping->host));brelse (bd->bd_bh); }
@@ -248,7 +246,7 @@ static void gfs2_ail2_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai) bd = list_entry(head->prev, struct gfs2_bufdata, bd_ail_st_list);gfs2_assert (sdp, bd->bd_ail == ai); -gfs2_remove_from_ail (bd->bd_bh->b_page->mapping, bd); +gfs2_remove_from_ail (bd); } }
fs/gfs2/log.h +1 -1
@@ -59,7 +59,7 @@ struct buffer_head *gfs2_log_fake_buf(struct gfs2_sbd *sdp, struct buffer_head *real);void gfs2_log_flush (struct gfs2_sbd *sdp,struct gfs2_glock *gl);void gfs2_log_commit (struct gfs2_sbd *sdp,struct gfs2_trans *trans); -void gfs2_remove_from_ail (struct address_space *mapping,struct gfs2_bufdata *bd); +void gfs2_remove_from_ail (struct gfs2_bufdata *bd);void gfs2_log_shutdown (struct gfs2_sbd *sdp);void gfs2_meta_syncfs (struct gfs2_sbd *sdp);
fs/gfs2/main.c +0 -1
@@ -31,7 +31,6 @@ static void gfs2_init_inode_once(struct kmem_cache *cachep, void *foo)inode_init_once (&ip->i_inode);spin_lock_init (&ip->i_spin);init_rwsem (&ip->i_rw_mutex); -memset (ip->i_cache,0 ,sizeof (ip->i_cache)); }static void gfs2_init_glock_once (struct kmem_cache *cachep,void *foo)
fs/gfs2/meta_io.c +10 -71
115 lines not on this page · raw message
fs/gfs2/meta_io.h +0 -1
@@ -56,7 +56,6 @@ void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr,void gfs2_meta_wipe (struct gfs2_inode *ip,u64 bstart,u32 blen); -void gfs2_meta_cache_flush (struct gfs2_inode *ip);int gfs2_meta_indirect_buffer (struct gfs2_inode *ip,int height,u64 num,int new,struct buffer_head **bhp);
fs/gfs2/ops_address.c +0 -1
@@ -154,7 +154,6 @@ static int gfs2_writepage(struct page *page, struct writeback_control *wbc) error =block_write_full_page (page, gfs2_get_block_noalloc, wbc);if (done_trans)gfs2_trans_end (sdp); -gfs2_meta_cache_flush (ip);return error; out_ignore:
fs/gfs2/super.c +0 -1
@@ -543,7 +543,6 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)if (error)return error; -gfs2_meta_cache_flush (ip); j_gl->gl_ops->go_inval (j_gl,DIO_METADATA ); error =gfs2_find_jhead (sdp->sd_jdesc, &head);
Signature · 1 line
1.5.1.2
PATCH 5/58 Remove unused field in struct gfs2_inode
From: Steven Whitehouse <[email protected]>
Removes a field that is not used.
fs/gfs2/incore.h +0 -1
@@ -274,7 +274,6 @@ struct gfs2_inode {spinlock_t i_spin;struct rw_semaphore i_rw_mutex; -unsigned long i_last_pfault; };/*
fs/gfs2/ops_super.c +0 -1
@@ -487,7 +487,6 @@ static struct inode *gfs2_alloc_inode(struct super_block *sb)if (ip) { ip->i_flags =0 ; ip->i_gl =NULL ; - ip->i_last_pfault = jiffies; }return &ip->i_inode; }
Signature · 1 line
1.5.1.2
PATCH 6/58 Add gfs2_is_writeback()
From: Steven Whitehouse <[email protected]>
This adds a function "gfs2_is_writeback()" along the lines of the existing "gfs2_is_jdata()" in order to clean up the code and make the various tests for the inode mode more obvious. It also fixes the PageChecked() logic where we were resetting the flag too early in the case of an error path.
fs/gfs2/bmap.c +2 -4
@@ -59,7 +59,6 @@ struct strip_mine {static int gfs2_unstuffer_page (struct gfs2_inode *ip,struct buffer_head *dibh,u64 block,struct page *page) { -struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode);struct inode *inode = &ip->i_inode;struct buffer_head *bh;int release =0 ;
@@ -95,7 +94,7 @@ static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,set_buffer_uptodate (bh);if (!gfs2_is_jdata (ip))mark_buffer_dirty (bh); -if (sdp->sd_args.ar_data ==GFS2_DATA_ORDERED ||gfs2_is_jdata (ip)) +if (!gfs2_is_writeback (ip))gfs2_trans_add_bh (ip->i_gl, bh,0 );if (release) {
@@ -879,7 +878,6 @@ static int gfs2_block_truncate_page(struct address_space *mapping) {struct inode *inode = mapping->host;struct gfs2_inode *ip =GFS2_I (inode); -struct gfs2_sbd *sdp =GFS2_SB (inode);loff_t from = inode->i_size;unsigned long index = from >>PAGE_CACHE_SHIFT ;unsigned offset = from & (PAGE_CACHE_SIZE -1 );
@@ -931,7 +929,7 @@ static int gfs2_block_truncate_page(struct address_space *mapping) err =0 ; } -if (sdp->sd_args.ar_data ==GFS2_DATA_ORDERED ||gfs2_is_jdata (ip)) +if (!gfs2_is_writeback (ip))gfs2_trans_add_bh (ip->i_gl, bh,0 );zero_user_page (page, offset, length,KM_USER0 );
fs/gfs2/incore.h +1 -1
@@ -285,7 +285,7 @@ static inline struct gfs2_inode *GFS2_I(struct inode *inode) return container_of(inode, struct gfs2_inode, i_inode); } -static inline struct gfs2_sbd *GFS2_SB (struct inode *inode) +static inline struct gfs2_sbd *GFS2_SB (const struct inode *inode) {return inode->i_sb->s_fs_info; }
fs/gfs2/inode.h +6 -0
@@ -20,6 +20,12 @@ static inline int gfs2_is_jdata(const struct gfs2_inode *ip)return ip->i_di.di_flags &GFS2_DIF_JDATA ; } +static inline int gfs2_is_writeback (const struct gfs2_inode *ip) +{ +const struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); +return (sdp->sd_args.ar_data ==GFS2_DATA_WRITEBACK ) && !gfs2_is_jdata (ip); +} +static inline int gfs2_is_dir (const struct gfs2_inode *ip) {return S_ISDIR (ip->i_inode.i_mode);
fs/gfs2/ops_address.c +4 -6
@@ -138,12 +138,11 @@ static int gfs2_writepage(struct page *page, struct writeback_control *wbc)return 0 ;/* don't care */ } -if ((sdp->sd_args.ar_data ==GFS2_DATA_ORDERED ||gfs2_is_jdata (ip)) && -PageChecked (page)) { -ClearPageChecked (page); +if (PageChecked (page)) { error =gfs2_trans_begin (sdp,RES_DINODE +1 ,0 );if (error) goto out_ignore; +ClearPageChecked (page);if (!page_has_buffers (page)) {create_empty_buffers (page, inode->i_sb->s_blocksize, (1 << BH_Dirty)|(1 << BH_Uptodate));
@@ -180,9 +179,8 @@ static int gfs2_writepages(struct address_space *mapping, {struct inode *inode = mapping->host;struct gfs2_inode *ip =GFS2_I (inode); -struct gfs2_sbd *sdp =GFS2_SB (inode); -if (sdp->sd_args.ar_data ==GFS2_DATA_WRITEBACK && !gfs2_is_jdata (ip)) +if (gfs2_is_writeback (ip))return mpage_writepages (mapping, wbc, gfs2_get_block_noalloc);return generic_writepages (mapping, wbc);
@@ -606,7 +604,7 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping,if (gfs2_is_stuffed (ip))return gfs2_stuffed_write_end (inode, dibh, pos, len, copied, page); -if (sdp->sd_args.ar_data ==GFS2_DATA_ORDERED ||gfs2_is_jdata (ip)) +if (!gfs2_is_writeback (ip))gfs2_page_add_databufs (ip, page, from, to); ret =generic_write_end (file, mapping, pos, len, copied, page, fsdata);
Signature · 1 line
1.5.1.2
PATCH 7/58 Introduce gfs2_set_aops()
From: Steven Whitehouse <[email protected]>
Just like ext3 we now have three sets of address space operations to cover the cases of writeback, ordered and journalled data writes. This means that the individual operations can now become less complicated as we are able to remove some of the tests for file data mode from the code.
fs/gfs2/inode.c +3 -1
@@ -136,7 +136,6 @@ void gfs2_set_iop(struct inode *inode)if (S_ISREG (mode)) { inode->i_op = &gfs2_file_iops; inode->i_fop = &gfs2_file_fops; - inode->i_mapping->a_ops = &gfs2_file_aops; }else if (S_ISDIR (mode)) { inode->i_op = &gfs2_dir_iops; inode->i_fop = &gfs2_dir_fops;
@@ -290,6 +289,9 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf) di->di_entries =be32_to_cpu (str->di_entries); di->di_eattr =be64_to_cpu (str->di_eattr); +if (S_ISREG (ip->i_inode.i_mode)) +gfs2_set_aops (&ip->i_inode); +return 0 ; }
fs/gfs2/inode.h +6 -0
@@ -26,6 +26,12 @@ static inline int gfs2_is_writeback(const struct gfs2_inode *ip)return (sdp->sd_args.ar_data ==GFS2_DATA_WRITEBACK ) && !gfs2_is_jdata (ip); } +static inline int gfs2_is_ordered (const struct gfs2_inode *ip) +{ +const struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); +return (sdp->sd_args.ar_data ==GFS2_DATA_ORDERED ) && !gfs2_is_jdata (ip); +} +static inline int gfs2_is_dir (const struct gfs2_inode *ip) {return S_ISDIR (ip->i_inode.i_mode);
fs/gfs2/ops_address.c +50 -28
114 lines not on this page · raw message
fs/gfs2/ops_address.h +1 -1
@@ -14,12 +14,12 @@#include <linux/buffer_head.h> #include <linux/mm.h> -extern const struct address_space_operations gfs2_file_aops;extern int gfs2_get_block (struct inode *inode,sector_t lblock,struct buffer_head *bh_result,int create);extern int gfs2_releasepage (struct page *page,gfp_t gfp_mask);extern int gfs2_internal_read (struct gfs2_inode *ip,struct file_ra_state *ra_state,char *buf,loff_t *pos,unsigned size); +extern void gfs2_set_aops (struct inode *inode);#endif /* __OPS_ADDRESS_DOT_H__ */
fs/gfs2/ops_file.c +12 -1
@@ -38,6 +38,7 @@#include "trans.h" #include "util.h" #include "eaops.h" +#include "ops_address.h" /** * gfs2_llseek - seek to a location in a file
@@ -245,7 +246,16 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)if (error) goto out; } - +if ((flags ^ new_flags) &GFS2_DIF_JDATA ) { +if (flags &GFS2_DIF_JDATA ) +gfs2_log_flush (sdp, ip->i_gl); + error =filemap_fdatawrite (inode->i_mapping); +if (error) + goto out; + error =filemap_fdatawait (inode->i_mapping); +if (error) + goto out; + } error =gfs2_trans_begin (sdp,RES_DINODE ,0 );if (error) goto out;
@@ -257,6 +267,7 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)gfs2_dinode_out (ip, bh->b_data);brelse (bh);gfs2_set_inode_flags (inode); +gfs2_set_aops (inode); out_trans_end:gfs2_trans_end (sdp); out:
Signature · 1 line
1.5.1.2
PATCH 8/58 Split gfs2_writepage into three cases
From: Steven Whitehouse <[email protected]>
This patch splits gfs2_writepage into separate functions for each of the three cases: writeback, ordered and journalled. As a result it becomes a lot easier to see what each one is doing. The common code is moved into gfs2_writepage_common.
This fixes a performance bug where we were doing more work than strictly required in the ordered write case.
fs/gfs2/lops.c +10 -7
@@ -556,17 +556,20 @@ static void databuf_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)lock_buffer (bd->bd_bh);gfs2_log_lock (sdp); -if (!list_empty (&bd->bd_list_tr)) - goto out; - tr->tr_touched =1 ; -if (gfs2_is_jdata (ip)) { - tr->tr_num_buf++; -list_add (&bd->bd_list_tr, &tr->tr_list_buf); +if (tr) { +if (!list_empty (&bd->bd_list_tr)) + goto out; + tr->tr_touched =1 ; +if (gfs2_is_jdata (ip)) { + tr->tr_num_buf++; +list_add (&bd->bd_list_tr, &tr->tr_list_buf); + } }if (!list_empty (&le->le_list)) goto out; -__glock_lo_add (sdp, &bd->bd_gl->gl_le); +if (tr) +__glock_lo_add (sdp, &bd->bd_gl->gl_le);if (gfs2_is_jdata (ip)) {gfs2_pin (sdp, bd->bd_bh); tr->tr_num_databuf_new++;
fs/gfs2/ops_address.c +91 -21
151 lines not on this page · raw message
Signature · 1 line
1.5.1.2
PATCH 9/58 Add writepages for GFS2 jdata
From: Steven Whitehouse <[email protected]>
This patch resolves a lock ordering issue where we had been getting a transaction lock in the wrong order with respect to the page lock. By using writepages rather than just writepage, it is then possible to start a transaction before locking the page, and thus matching the locking order elsewhere in the code.
fs/gfs2/log.c +1 -1
@@ -650,7 +650,7 @@ static void gfs2_ordered_write(struct gfs2_sbd *sdp)get_bh (bh);gfs2_log_unlock (sdp);lock_buffer (bh); -if (test_clear_buffer_dirty (bh)) { +if (buffer_mapped (bh) &&test_clear_buffer_dirty (bh)) { bh->b_end_io = end_buffer_write_sync;submit_bh (WRITE , bh); }else {
fs/gfs2/ops_address.c +205 -8
254 lines not on this page · raw message
Signature · 1 line
1.5.1.2
PATCH 10/58 Don't hold page lock when starting transaction
From: Steven Whitehouse <[email protected]>
This is an addendum to the new AOPs work which moves the point at which we take the page lock so that we don't get it until the last possible moment. This resolves a conflict between starting transactions and the page lock.
fs/gfs2/ops_address.c +25 -26
@@ -657,18 +657,10 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping,if (unlikely (error)) goto out_uninit; - error = -ENOMEM ; - page =__grab_cache_page (mapping, index); - *pagep = page; -if (!page) - goto out_unlock; -gfs2_write_calc_reserv (ip, len, &data_blocks, &ind_blocks); - error =gfs2_write_alloc_required (ip, pos, len, &alloc_required);if (error) - goto out_putpage; - + goto out_unlock; ip->i_alloc.al_requested =0 ;if (alloc_required) {
@@ -699,40 +691,47 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping,if (error) goto out_trans_fail; + error = -ENOMEM ; + page =__grab_cache_page (mapping, index); + *pagep = page; +if (unlikely (!page)) + goto out_endtrans; +if (gfs2_is_stuffed (ip)) { + error =0 ;if (pos + len > sdp->sd_sb.sb_bsize -sizeof (struct gfs2_dinode )) { error =gfs2_unstuff_dinode (ip, page);if (error ==0 ) goto prepare_write; - }else if (!PageUptodate (page)) + }else if (!PageUptodate (page)) { error =stuffed_readpage (ip, page); + } goto out; } prepare_write: error =block_prepare_write (page, from, to, gfs2_get_block); - out: -if (error) { -gfs2_trans_end (sdp); +if (error ==0 ) +return 0 ; + +page_cache_release (page); +if (pos + len > ip->i_inode.i_size) +vmtruncate (&ip->i_inode, ip->i_inode.i_size); +out_endtrans: +gfs2_trans_end (sdp); out_trans_fail: -if (alloc_required) { -gfs2_inplace_release (ip); +if (alloc_required) { +gfs2_inplace_release (ip); out_qunlock: -gfs2_quota_unlock (ip); +gfs2_quota_unlock (ip); out_alloc_put: -gfs2_alloc_put (ip); - } -out_putpage: -page_cache_release (page); -if (pos + len > ip->i_inode.i_size) -vmtruncate (&ip->i_inode, ip->i_inode.i_size); +gfs2_alloc_put (ip); + } out_unlock: -gfs2_glock_dq_m (1 , &ip->i_gh); +gfs2_glock_dq (&ip->i_gh); out_uninit: -gfs2_holder_uninit (&ip->i_gh); - } - +gfs2_holder_uninit (&ip->i_gh);return error; }
Signature · 1 line
1.5.1.2
PATCH 11/58 Use correct include file in ops_address.c
From: Steven Whitehouse <[email protected]>
Something changed in the upstream kernel, and it needs this one-liner to allow ops_address.c to build.
fs/gfs2/ops_address.c +1 -1
@@ -20,7 +20,7 @@#include <linux/swap.h> #include <linux/gfs2_ondisk.h> #include <linux/lm_interface.h> -#include <linux/swap.h> +#include <linux/backing-dev.h> #include <linux/pagevec.h> #include "gfs2.h"
Signature · 1 line
1.5.1.2
PATCH 12/58 Remove unused variables
From: Steven Whitehouse <[email protected]>
These haven't been used for some time, remove them.
fs/gfs2/incore.h +0 -4
@@ -412,9 +412,6 @@ struct gfs2_args {struct gfs2_tune {spinlock_t gt_spin; -unsigned int gt_ilimit; -unsigned int gt_ilimit_tries; -unsigned int gt_ilimit_min;unsigned int gt_demote_secs;/* Cache retention for unheld glock */ unsigned int gt_incore_log_blocks;unsigned int gt_log_flush_secs;
@@ -434,7 +431,6 @@ struct gfs2_tune {unsigned int gt_new_files_jdata;unsigned int gt_new_files_directio;unsigned int gt_max_readahead;/* Max bytes to read-ahead from disk */ -unsigned int gt_lockdump_size;unsigned int gt_stall_secs;/* Detects trouble! */ unsigned int gt_complain_secs;unsigned int gt_reclaim_limit;/* Max num of glocks in reclaim list */
fs/gfs2/super.c +0 -4
@@ -51,9 +51,6 @@ void gfs2_tune_init(struct gfs2_tune *gt) {spin_lock_init (>->gt_spin); - gt->gt_ilimit =100 ; - gt->gt_ilimit_tries =3 ; - gt->gt_ilimit_min =1 ; gt->gt_demote_secs =300 ; gt->gt_incore_log_blocks =1024 ; gt->gt_log_flush_secs =60 ;
@@ -71,7 +68,6 @@ void gfs2_tune_init(struct gfs2_tune *gt) gt->gt_new_files_jdata =0 ; gt->gt_new_files_directio =0 ; gt->gt_max_readahead =1 <<18 ; - gt->gt_lockdump_size =131072 ; gt->gt_stall_secs =600 ; gt->gt_complain_secs =10 ; gt->gt_reclaim_limit =5000 ;
Signature · 1 line
1.5.1.2
PATCH 13/58 Remove "reclaim limit"
From: Steven Whitehouse <[email protected]>
This call to reclaim glocks is not needed, and in particular we don't want it in the fast path for locking glocks. The limit was entirely arbitrary anyway and we can't expect users to adjust things like this, the remaining code will do the right thing on its own.
fs/gfs2/glock.c +0 -9
@@ -507,21 +507,12 @@ static int rq_mutex(struct gfs2_holder *gh)static int rq_promote (struct gfs2_holder *gh) {struct gfs2_glock *gl = gh->gh_gl; -struct gfs2_sbd *sdp = gl->gl_sbd;if (!relaxed_state_ok (gl->gl_state, gh->gh_state, gh->gh_flags)) {if (list_empty (&gl->gl_holders)) { gl->gl_req_gh = gh;set_bit (GLF_LOCK , &gl->gl_flags);spin_unlock (&gl->gl_spin); - -if (atomic_read (&sdp->sd_reclaim_count) > -gfs2_tune_get (sdp, gt_reclaim_limit) && - !(gh->gh_flags &LM_FLAG_PRIORITY )) { -gfs2_reclaim_glock (sdp); -gfs2_reclaim_glock (sdp); - } -gfs2_glock_xmote_th (gh->gh_gl, gh);spin_lock (&gl->gl_spin); }
fs/gfs2/incore.h +0 -1
@@ -433,7 +433,6 @@ struct gfs2_tune {unsigned int gt_max_readahead;/* Max bytes to read-ahead from disk */ unsigned int gt_stall_secs;/* Detects trouble! */ unsigned int gt_complain_secs; -unsigned int gt_reclaim_limit;/* Max num of glocks in reclaim list */ unsigned int gt_statfs_quantum;unsigned int gt_statfs_slow; };
fs/gfs2/super.c +0 -1
@@ -70,7 +70,6 @@ void gfs2_tune_init(struct gfs2_tune *gt) gt->gt_max_readahead =1 <<18 ; gt->gt_stall_secs =600 ; gt->gt_complain_secs =10 ; - gt->gt_reclaim_limit =5000 ; gt->gt_statfs_quantum =30 ; gt->gt_statfs_slow =0 ; }
fs/gfs2/sys.c +0 -2
@@ -433,7 +433,6 @@ TUNE_ATTR(quota_quantum, 0);TUNE_ATTR (atime_quantum,0 );TUNE_ATTR (max_readahead,0 );TUNE_ATTR (complain_secs,0 ); -TUNE_ATTR (reclaim_limit,0 );TUNE_ATTR (statfs_slow,0 );TUNE_ATTR (new_files_jdata,0 );TUNE_ATTR (new_files_directio,0 );
@@ -456,7 +455,6 @@ static struct attribute *tune_attrs[] = { &tune_attr_atime_quantum.attr, &tune_attr_max_readahead.attr, &tune_attr_complain_secs.attr, - &tune_attr_reclaim_limit.attr, &tune_attr_statfs_slow.attr, &tune_attr_quota_simul_sync.attr, &tune_attr_quota_cache_secs.attr,
Signature · 1 line
1.5.1.2
PATCH 14/58 Add sync_page to metadata address space operations
From: Steven Whitehouse <[email protected]>
This set of address space operations was missing a sync_page operation.
fs/gfs2/meta_io.c +1 -0
@@ -50,6 +50,7 @@ static int gfs2_aspace_writepage(struct page *page,static const struct address_space_operations aspace_aops = { .writepage = gfs2_aspace_writepage, .releasepage = gfs2_releasepage, + .sync_page = block_sync_page, };/**
Signature · 1 line
1.5.1.2
PATCH 15/58 Reorder writeback for glock sync
From: Steven Whitehouse <[email protected]>
Previously we were doing (write data, wait for data, write metadata, wait for metadata). After this patch we so (write metadata, write data, wait for data, wait for metadata) which should be more efficient.
Also I noticed that the drop_bh and xmote_bh functions were almost identical. In fact the only difference was a single test, and that test is such that in the drop_bh case, it would always evaluate to the correct result. As such we can use the xmote_bh functions in all the places where we were using the drop_bh function and remove the drop_bh functions.
fs/gfs2/glock.c +6 -7
@@ -947,8 +947,8 @@ static void gfs2_glock_drop_th(struct gfs2_glock *gl)const struct gfs2_glock_operations *glops = gl->gl_ops;unsigned int ret; -if (glops->go_drop_th) - glops->go_drop_th (gl); +if (glops->go_xmote_th) + glops->go_xmote_th (gl);gfs2_assert_warn (sdp,test_bit (GLF_LOCK , &gl->gl_flags));gfs2_assert_warn (sdp,list_empty (&gl->gl_holders));
@@ -1252,12 +1252,11 @@ void gfs2_glock_dq(struct gfs2_holder *gh)list_del_init (&gh->gh_list);if (list_empty (&gl->gl_holders)) { -spin_unlock (&gl->gl_spin); - -if (glops->go_unlock) +if (glops->go_unlock) { +spin_unlock (&gl->gl_spin); glops->go_unlock (gh); - -spin_lock (&gl->gl_spin); +spin_lock (&gl->gl_spin); + } gl->gl_stamp = jiffies; }
fs/gfs2/glops.c +16 -64
150 lines not on this page · raw message
Signature · 1 line
1.5.1.2
PATCH 16/58 Remove flags no longer required
From: Steven Whitehouse <[email protected]>
The HIF_MUTEX and HIF_PROMOTE flags were set on the glock holders depending upon which of the two waiters lists they were going to be queued upon. They were then tested when the holders were taken off the lists to ensure that the right type of holder was being dequeued.
Since we are already using separate lists, there doesn't seem a lot of point having these flags as well, and since setting them and testing them is in the fast path for locking and unlocking glock, this patch removes them.
fs/gfs2/glock.c +2 -15
@@ -594,12 +594,7 @@ static void run_queue(struct gfs2_glock *gl)if (!list_empty (&gl->gl_waiters1)) { gh =list_entry (gl->gl_waiters1.next, struct gfs2_holder, gh_list); - -if (test_bit (HIF_MUTEX , &gh->gh_iflags)) - blocked =rq_mutex (gh); -else -gfs2_assert_warn (gl->gl_sbd,0 ); - + blocked =rq_mutex (gh); }else if (test_bit (GLF_DEMOTE , &gl->gl_flags)) { blocked =rq_demote (gl);if (gl->gl_waiters2 && !blocked) {
@@ -610,12 +605,7 @@ static void run_queue(struct gfs2_glock *gl) }else if (!list_empty (&gl->gl_waiters3)) { gh =list_entry (gl->gl_waiters3.next, struct gfs2_holder, gh_list); - -if (test_bit (HIF_PROMOTE , &gh->gh_iflags)) - blocked =rq_promote (gh); -else -gfs2_assert_warn (gl->gl_sbd,0 ); - + blocked =rq_promote (gh); }else break ;
@@ -636,7 +626,6 @@ static void gfs2_glmutex_lock(struct gfs2_glock *gl)struct gfs2_holder gh;gfs2_holder_init (gl,0 ,0 , &gh); -set_bit (HIF_MUTEX , &gh.gh_iflags);if (test_and_set_bit (HIF_WAIT , &gh.gh_iflags))BUG ();
@@ -1160,8 +1149,6 @@ restart:return -EIO ; } -set_bit (HIF_PROMOTE , &gh->gh_iflags); -spin_lock (&gl->gl_spin);add_to_queue (gh);run_queue (gl);
fs/gfs2/incore.h +0 -4
@@ -141,10 +141,6 @@ struct gfs2_glock_operations { };enum { -/* Actions */ -HIF_MUTEX =0 , -HIF_PROMOTE =1 , -/* States */ HIF_HOLDER =6 ,HIF_FIRST =7 ,
Signature · 1 line
1.5.1.2
PATCH 17/58 Given device ID rather than s_id in "id" sysfs file
From: Bob Peterson <[email protected]>
This patch changes the /sys/fs/gfs2/<s_id>/id file to give the device id "major:minor" rather than the s_id. That enables gfs2_tool to match devices properly (by id, not name) when locating the tuning files.
fs/gfs2/sys.c +2 -1
@@ -32,7 +32,8 @@ spinlock_t gfs2_sys_margs_lock;static ssize_t id_show (struct gfs2_sbd *sdp,char *buf) { -return snprintf (buf,PAGE_SIZE ,"%s\n" , sdp->sd_vfs->s_id); +return snprintf (buf,PAGE_SIZE ,"%u:%u\n" , +MAJOR (sdp->sd_vfs->s_dev),MINOR (sdp->sd_vfs->s_dev)); }static ssize_t fsname_show (struct gfs2_sbd *sdp,char *buf)
Signature · 1 line
1.5.1.2
PATCH 18/58 check kthread_should_stop when waiting
From: David Teigland <[email protected]>
Use wait_event_interruptible() in the lock_dlm thread instead of an open coded equivalent, and include a kthread_should_stop() check in the wait test so we don't miss a kthread_stop().
fs/gfs2/locking/dlm/thread.c +2 -7
@@ -273,18 +273,13 @@ static int gdlm_thread(void *data, int blist)struct gdlm_ls *ls = (struct gdlm_ls *) data;struct gdlm_lock *lp =NULL ;uint8_t complete, blocking, submit, drop; -DECLARE_WAITQUEUE (wait, current);/* Only thread1 is allowed to do blocking callbacks since gfs may wait for a completion callback within a blocking cb. */ while (!kthread_should_stop ()) { -set_current_state (TASK_INTERRUPTIBLE ); -add_wait_queue (&ls->thread_wait, &wait); -if (no_work (ls, blist)) -schedule (); -remove_wait_queue (&ls->thread_wait, &wait); -set_current_state (TASK_RUNNING ); +wait_event_interruptible (ls->thread_wait, + !no_work (ls, blist) ||kthread_should_stop ()); complete = blocking = submit = drop =0 ;
Signature · 1 line
1.5.1.2
PATCH 19/58 Don't add glocks to the journal
From: Steven Whitehouse <[email protected]>
The only reason for adding glocks to the journal was to keep track of which locks required a log flush prior to release. We add a flag to the glock to allow this check to be made in a simpler way.
This reduces the size of a glock (by 12 bytes on i386, 24 on x86_64) and means that we can avoid extra work during the journal flush.
fs/gfs2/glock.c +0 -3
@@ -346,7 +346,6 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, gl->gl_object =NULL ; gl->gl_sbd = sdp; gl->gl_aspace =NULL ; -lops_init_le (&gl->gl_le, &gfs2_glock_lops);INIT_DELAYED_WORK (&gl->gl_work, glock_work_func);/* If this glock protects actual on-disk data or metadata blocks,
@@ -1900,8 +1899,6 @@ static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl)print_dbg (gi," req_bh = %s\n" , (gl->gl_req_bh) ?"yes" :"no" );print_dbg (gi," lvb_count = %d\n" ,atomic_read (&gl->gl_lvb_count));print_dbg (gi," object = %s\n" , (gl->gl_object) ?"yes" :"no" ); -print_dbg (gi," le = %s\n" , - (list_empty (&gl->gl_le.le_list)) ?"no" :"yes" );print_dbg (gi," reclaim = %s\n" , (list_empty (&gl->gl_reclaim)) ?"no" :"yes" );if (gl->gl_aspace)
fs/gfs2/incore.h +1 -3
@@ -168,6 +168,7 @@ enum {GLF_PENDING_DEMOTE =4 ,GLF_DIRTY =5 ,GLF_DEMOTE_IN_PROGRESS =6 , + GLF_LFLUSH = 7, }; struct gfs2_glock {
@@ -208,7 +209,6 @@ struct gfs2_glock {struct gfs2_sbd *gl_sbd;struct inode *gl_aspace; -struct gfs2_log_element gl_le;struct list_head gl_ail_list;atomic_t gl_ail_count;struct delayed_work gl_work;
@@ -584,13 +584,11 @@ struct gfs2_sbd {unsigned int sd_log_commited_databuf;unsigned int sd_log_commited_revoke; -unsigned int sd_log_num_gl;unsigned int sd_log_num_buf;unsigned int sd_log_num_revoke;unsigned int sd_log_num_rg;unsigned int sd_log_num_databuf; -struct list_head sd_log_le_gl;struct list_head sd_log_le_buf;struct list_head sd_log_le_revoke;struct list_head sd_log_le_rg;
fs/gfs2/inode.c +2 -1
@@ -362,7 +362,8 @@ int gfs2_dinode_dealloc(struct gfs2_inode *ip)if (error) goto out_rg_gunlock; -gfs2_trans_add_gl (ip->i_gl); +set_bit (GLF_DIRTY , &ip->i_gl->gl_flags); +set_bit (GLF_LFLUSH , &ip->i_gl->gl_flags);gfs2_free_di (rgd, ip);
fs/gfs2/log.c +5 -10
@@ -692,20 +692,16 @@ static void gfs2_ordered_wait(struct gfs2_sbd *sdp)* */ -void gfs2_log_flush (struct gfs2_sbd *sdp,struct gfs2_glock *gl) +void __gfs2_log_flush (struct gfs2_sbd *sdp,struct gfs2_glock *gl) {struct gfs2_ail *ai;down_write (&sdp->sd_log_flush_lock); -if (gl) { -gfs2_log_lock (sdp); -if (list_empty (&gl->gl_le.le_list)) { -gfs2_log_unlock (sdp); -up_write (&sdp->sd_log_flush_lock); -return ; - } -gfs2_log_unlock (sdp); +/* Log might have been flushed while we waited for the flush lock */ +if (gl && !test_bit (GLF_LFLUSH , &gl->gl_flags)) { +up_write (&sdp->sd_log_flush_lock); +return ; } ai =kzalloc (sizeof (struct gfs2_ail ),GFP_NOFS | __GFP_NOFAIL);
@@ -823,7 +819,6 @@ void gfs2_log_shutdown(struct gfs2_sbd *sdp)down_write (&sdp->sd_log_flush_lock);gfs2_assert_withdraw (sdp, !sdp->sd_log_blks_reserved); -gfs2_assert_withdraw (sdp, !sdp->sd_log_num_gl);gfs2_assert_withdraw (sdp, !sdp->sd_log_num_buf);gfs2_assert_withdraw (sdp, !sdp->sd_log_num_revoke);gfs2_assert_withdraw (sdp, !sdp->sd_log_num_rg);
fs/gfs2/log.h +8 -1
@@ -57,7 +57,14 @@ void gfs2_log_incr_head(struct gfs2_sbd *sdp);struct buffer_head *gfs2_log_get_buf (struct gfs2_sbd *sdp);struct buffer_head *gfs2_log_fake_buf (struct gfs2_sbd *sdp,struct buffer_head *real); -void gfs2_log_flush (struct gfs2_sbd *sdp,struct gfs2_glock *gl); +void __gfs2_log_flush (struct gfs2_sbd *sdp,struct gfs2_glock *gl); + +static inline void gfs2_log_flush (struct gfs2_sbd *sbd,struct gfs2_glock *gl) +{ +if (!gl ||test_bit (GLF_LFLUSH , &gl->gl_flags)) +__gfs2_log_flush (sbd, gl); +} +void gfs2_log_commit (struct gfs2_sbd *sdp,struct gfs2_trans *trans);void gfs2_remove_from_ail (struct gfs2_bufdata *bd);
fs/gfs2/lops.c +5 -53
94 lines not on this page · raw message
fs/gfs2/ops_fstype.c +0 -1
@@ -77,7 +77,6 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)spin_lock_init (&sdp->sd_log_lock); -INIT_LIST_HEAD (&sdp->sd_log_le_gl);INIT_LIST_HEAD (&sdp->sd_log_le_buf);INIT_LIST_HEAD (&sdp->sd_log_le_revoke);INIT_LIST_HEAD (&sdp->sd_log_le_rg);
fs/gfs2/trans.c +0 -5
@@ -114,11 +114,6 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)gfs2_log_flush (sdp,NULL ); } -void gfs2_trans_add_gl (struct gfs2_glock *gl) -{ -lops_add (gl->gl_sbd, &gl->gl_le); -} -/** * gfs2_trans_add_bh - Add a to-be-modified buffer to the current transaction * @gl: the glock the buffer belongs to
fs/gfs2/trans.h +0 -1
@@ -30,7 +30,6 @@ int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,void gfs2_trans_end (struct gfs2_sbd *sdp); -void gfs2_trans_add_gl (struct gfs2_glock *gl);void gfs2_trans_add_bh (struct gfs2_glock *gl,struct buffer_head *bh,int meta);void gfs2_trans_add_revoke (struct gfs2_sbd *sdp,struct gfs2_bufdata *bd);void gfs2_trans_add_unrevoke (struct gfs2_sbd *sdp,u64 blkno);
Signature · 1 line
1.5.1.2
PATCH 20/58 Use atomic_t for journal free blocks counter
From: Steven Whitehouse <[email protected]>
This patch changes the counter which keeps track of the free blocks in the journal to an atomic_t in preparation for the following patch which will update the log reservation code.
fs/gfs2/incore.h +1 -1
@@ -595,7 +595,7 @@ struct gfs2_sbd {struct list_head sd_log_le_databuf;struct list_head sd_log_le_ordered; -unsigned int sd_log_blks_free; +atomic_t sd_log_blks_free;struct mutex sd_log_reserve_mutex;u64 sd_log_sequence;
fs/gfs2/log.c +13 -13
@@ -301,7 +301,7 @@ int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)mutex_lock (&sdp->sd_log_reserve_mutex);gfs2_log_lock (sdp); -while (sdp->sd_log_blks_free <= (blks + reserved_blks)) { +while (atomic_read (&sdp->sd_log_blks_free) <= (blks + reserved_blks)) {gfs2_log_unlock (sdp);gfs2_ail1_empty (sdp,0 );gfs2_log_flush (sdp,NULL );
@@ -310,7 +310,7 @@ int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)gfs2_ail1_start (sdp,0 );gfs2_log_lock (sdp); } - sdp->sd_log_blks_free -= blks; +atomic_sub (blks, &sdp->sd_log_blks_free);gfs2_log_unlock (sdp);mutex_unlock (&sdp->sd_log_reserve_mutex);
@@ -330,9 +330,9 @@ void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks) {gfs2_log_lock (sdp); - sdp->sd_log_blks_free += blks; +atomic_add (blks, &sdp->sd_log_blks_free);gfs2_assert_withdraw (sdp, - sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks); +atomic_read (&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);gfs2_log_unlock (sdp);up_read (&sdp->sd_log_flush_lock); }
@@ -559,8 +559,8 @@ static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail)ail2_empty (sdp, new_tail);gfs2_log_lock (sdp); - sdp->sd_log_blks_free += dist; -gfs2_assert_withdraw (sdp, sdp->sd_log_blks_free <= sdp->sd_jdesc->jd_blocks); +atomic_add (dist, &sdp->sd_log_blks_free); +gfs2_assert_withdraw (sdp,atomic_read (&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);gfs2_log_unlock (sdp); sdp->sd_log_tail = new_tail;
@@ -733,7 +733,7 @@ void __gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl)log_flush_commit (sdp); else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){gfs2_log_lock (sdp); - sdp->sd_log_blks_free--;/* Adjust for unreserved buffer */ +atomic_dec (&sdp->sd_log_blks_free);/* Adjust for unreserved buffer */ gfs2_log_unlock (sdp);log_write_header (sdp,0 ,PULL ); }
@@ -773,12 +773,12 @@ static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;gfs2_assert_withdraw (sdp, ((int )sdp->sd_log_commited_revoke) >=0 ); reserved =calc_reserved (sdp); - old = sdp->sd_log_blks_free; - sdp->sd_log_blks_free += tr->tr_reserved - - (reserved - sdp->sd_log_blks_reserved); + old =atomic_read (&sdp->sd_log_blks_free); +atomic_add (tr->tr_reserved - (reserved - sdp->sd_log_blks_reserved), + &sdp->sd_log_blks_free); -gfs2_assert_withdraw (sdp, sdp->sd_log_blks_free >= old); -gfs2_assert_withdraw (sdp, sdp->sd_log_blks_free <= +gfs2_assert_withdraw (sdp,atomic_read (&sdp->sd_log_blks_free) >= old); +gfs2_assert_withdraw (sdp,atomic_read (&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks); sdp->sd_log_blks_reserved = reserved;
@@ -831,7 +831,7 @@ void gfs2_log_shutdown(struct gfs2_sbd *sdp)log_write_header (sdp,GFS2_LOG_HEAD_UNMOUNT , (sdp->sd_log_tail ==current_tail (sdp)) ?0 :PULL ); -gfs2_assert_warn (sdp, sdp->sd_log_blks_free == sdp->sd_jdesc->jd_blocks); +gfs2_assert_warn (sdp,atomic_read (&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks);gfs2_assert_warn (sdp, sdp->sd_log_head == sdp->sd_log_tail);gfs2_assert_warn (sdp,list_empty (&sdp->sd_ail2_list));
fs/gfs2/ops_fstype.c +2 -2
@@ -339,7 +339,7 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)if (sdp->sd_args.ar_spectator) { sdp->sd_jdesc =gfs2_jdesc_find (sdp,0 ); - sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks; +atomic_set (&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks); }else {if (sdp->sd_lockstruct.ls_jid >=gfs2_jindex_size (sdp)) { fs_err(sdp, "can't mount journal #%u\n",
@@ -376,7 +376,7 @@ static int init_journal(struct gfs2_sbd *sdp, int undo) sdp->sd_jdesc->jd_jid, error); goto fail_jinode_gh; } - sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks; +atomic_set (&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks); }if (sdp->sd_lockstruct.ls_first) {
Signature · 1 line
1.5.1.2
PATCH 21/58 Move gfs2_logd into log.c
From: Steven Whitehouse <[email protected]>
This means that we can mark gfs2_ail1_empty static and prepares the way for further changes.
fs/gfs2/daemon.c +0 -50
@@ -83,56 +83,6 @@ int gfs2_recoverd(void *data) }/** -* gfs2_logd - Update log tail as Active Items get flushed to in-place blocks -* @sdp: Pointer to GFS2 superblock -* -* Also, periodically check to make sure that we're using the most recent -* journal index. -*/ - -int gfs2_logd (void *data) -{ -struct gfs2_sbd *sdp = data; -struct gfs2_holder ji_gh; -unsigned long t; -int need_flush; - -while (!kthread_should_stop ()) { -/* Advance the log tail */ - - t = sdp->sd_log_flush_time + -gfs2_tune_get (sdp, gt_log_flush_secs) *HZ ; - -gfs2_ail1_empty (sdp,DIO_ALL ); -gfs2_log_lock (sdp); - need_flush = sdp->sd_log_num_buf >gfs2_tune_get (sdp, gt_incore_log_blocks); -gfs2_log_unlock (sdp); -if (need_flush ||time_after_eq (jiffies, t)) { -gfs2_log_flush (sdp,NULL ); - sdp->sd_log_flush_time = jiffies; - } - -/* Check for latest journal index */ - - t = sdp->sd_jindex_refresh_time + -gfs2_tune_get (sdp, gt_jindex_refresh_secs) *HZ ; - -if (time_after_eq (jiffies, t)) { -if (!gfs2_jindex_hold (sdp, &ji_gh)) -gfs2_glock_dq_uninit (&ji_gh); - sdp->sd_jindex_refresh_time = jiffies; - } - - t =gfs2_tune_get (sdp, gt_logd_secs) *HZ ; -if (freezing (current)) -refrigerator (); -schedule_timeout_interruptible (t); - } - -return 0 ; -} - -/** * gfs2_quotad - Write cached quota changes into the quota file * @sdp: Pointer to GFS2 superblock *
fs/gfs2/daemon.h +0 -1
@@ -12,7 +12,6 @@int gfs2_glockd (void *data);int gfs2_recoverd (void *data); -int gfs2_logd (void *data);int gfs2_quotad (void *data);#endif /* __DAEMON_DOT_H__ */
fs/gfs2/log.c +55 -1
77 lines not on this page · raw message
fs/gfs2/log.h +1 -2
@@ -48,8 +48,6 @@ static inline void gfs2_log_pointers_init(struct gfs2_sbd *sdp,unsigned int gfs2_struct2blk (struct gfs2_sbd *sdp,unsigned int nstruct,unsigned int ssize); -int gfs2_ail1_empty (struct gfs2_sbd *sdp,int flags); -int gfs2_log_reserve (struct gfs2_sbd *sdp,unsigned int blks);void gfs2_log_release (struct gfs2_sbd *sdp,unsigned int blks);void gfs2_log_incr_head (struct gfs2_sbd *sdp);
@@ -70,5 +68,6 @@ void gfs2_remove_from_ail(struct gfs2_bufdata *bd);void gfs2_log_shutdown (struct gfs2_sbd *sdp);void gfs2_meta_syncfs (struct gfs2_sbd *sdp); +int gfs2_logd (void *data);#endif /* __LOG_DOT_H__ */
Signature · 1 line
1.5.1.2
PATCH 22/58 Don't periodically update the jindex
From: Steven Whitehouse <[email protected]>
We only care about the content of the jindex in two cases, one is when we mount the fs and the other is when we need to recover another journal. In both cases we have to update the jindex anyway, so there is no point in updating it periodically between times, so this removes it to simplify gfs2_logd.
fs/gfs2/incore.h +0 -1
@@ -411,7 +411,6 @@ struct gfs2_tune {unsigned int gt_demote_secs;/* Cache retention for unheld glock */ unsigned int gt_incore_log_blocks;unsigned int gt_log_flush_secs; -unsigned int gt_jindex_refresh_secs;/* Check for new journal index */ unsigned int gt_recoverd_secs;unsigned int gt_logd_secs;
fs/gfs2/log.c +0 -13
@@ -28,7 +28,6 @@#include "meta_io.h" #include "util.h" #include "dir.h" -#include "super.h" #define PULL 1
@@ -874,7 +873,6 @@ void gfs2_meta_syncfs(struct gfs2_sbd *sdp)int gfs2_logd (void *data) {struct gfs2_sbd *sdp = data; -struct gfs2_holder ji_gh;unsigned long t;int need_flush;
@@ -893,17 +891,6 @@ int gfs2_logd(void *data) sdp->sd_log_flush_time = jiffies; } -/* Check for latest journal index */ - - t = sdp->sd_jindex_refresh_time + -gfs2_tune_get (sdp, gt_jindex_refresh_secs) *HZ ; - -if (time_after_eq (jiffies, t)) { -if (!gfs2_jindex_hold (sdp, &ji_gh)) -gfs2_glock_dq_uninit (&ji_gh); - sdp->sd_jindex_refresh_time = jiffies; - } - t =gfs2_tune_get (sdp, gt_logd_secs) *HZ ;if (freezing (current))refrigerator ();
fs/gfs2/super.c +0 -1
@@ -54,7 +54,6 @@ void gfs2_tune_init(struct gfs2_tune *gt) gt->gt_demote_secs =300 ; gt->gt_incore_log_blocks =1024 ; gt->gt_log_flush_secs =60 ; - gt->gt_jindex_refresh_secs =60 ; gt->gt_recoverd_secs =60 ; gt->gt_logd_secs =1 ; gt->gt_quotad_secs =5 ;
fs/gfs2/sys.c +0 -2
@@ -428,7 +428,6 @@ TUNE_ATTR_2(name, name##_store)TUNE_ATTR (demote_secs,0 );TUNE_ATTR (incore_log_blocks,0 );TUNE_ATTR (log_flush_secs,0 ); -TUNE_ATTR (jindex_refresh_secs,0 );TUNE_ATTR (quota_warn_period,0 );TUNE_ATTR (quota_quantum,0 );TUNE_ATTR (atime_quantum,0 );
@@ -450,7 +449,6 @@ static struct attribute *tune_attrs[] = { &tune_attr_demote_secs.attr, &tune_attr_incore_log_blocks.attr, &tune_attr_log_flush_secs.attr, - &tune_attr_jindex_refresh_secs.attr, &tune_attr_quota_warn_period.attr, &tune_attr_quota_quantum.attr, &tune_attr_atime_quantum.attr,
Signature · 1 line
1.5.1.2
PATCH 23/58 Check for installation of mount helpers for DLM mounts
From: Fabio Massimo Di Nitto <[email protected]>
The patch is a fix to abort mount if the mount.gfs* and possible umount.* are missing from /sbin.
While we do what we can to guarantee that they are installed properly in userland (CVS HEAD), we want to make sure that mount still aborts properly.
The only sign of missing helpers is that lock_dlm will receive no mount options at all. According to David the problem does not exist for lock_nolock as the helpers are not required.
The patch has been tested for both gfs and gfs2 and it works as expected. The lack of mount.gfs* will generate an error that is propagated to mount:
oot at node1:~# mount -t gfs2 /dev/nbd2 /mnt/
mount: wrong fs type, bad option, bad superblock on /dev/nbd2,
missing codepage or helper program, or other error In some cases useful info is found in syslog - try dmesg | tail or so
[ 3513.303346] GFS2: fsid=: Trying to join cluster "lock_dlm", "gutsy:gfs2" [ 3513.304546] DLM/GFS2/GFS ERROR: (u)mount helpers are not installed properly! [ 3513.306290] GFS2: fsid=: can't mount proto=lock_dlm, table=gutsy:gfs2, hostdata=
You might want to notice that it will also avoid mount to hang or fail silently or with strange errors that will require the cluster to reboot/restart before you can actually mount the filesystem again.
fs/gfs2/locking/dlm/mount.c +6 -0
@@ -67,6 +67,12 @@ static int make_args(struct gdlm_ls *ls, char *data_arg, int *nodir)memset (data,0 ,256 );strncpy (data, data_arg,255 ); +if (!strlen (data)) { +printk (KERN_ERR +"DLM/GFS2/GFS ERROR: (u)mount helpers are not installed!\n" ); +return -EINVAL ; + } +for (options = data; (x =strsep (&options,":" )); ) {if (!*x)continue ;
Signature · 1 line
1.5.1.2
PATCH 24/58 tidy up error message
From: David Teigland <[email protected]>
Print error with log_error() to be consistent with others.
fs/gfs2/locking/dlm/mount.c +1 -2
@@ -68,8 +68,7 @@ static int make_args(struct gdlm_ls *ls, char *data_arg, int *nodir)strncpy (data, data_arg,255 );if (!strlen (data)) { -printk (KERN_ERR -"DLM/GFS2/GFS ERROR: (u)mount helpers are not installed!\n" ); +log_error ("no mount options, (u)mount helpers not installed" );return -EINVAL ; }
Signature · 1 line
1.5.1.2
PATCH 25/58 Fix runtime issue with UP kernels
From: Fabio Massimo Di Nitto <[email protected]>
The issue is indeed UP vs SMP and it is totally random.
spin_is_locked() is a bad assertion because there is no correct answer on UP. on UP spin_is_locked() has to return either one value or another, always.
This means that in my setup I am lucky enough to trigger the issue and your you are lucky enough not to.
the patch in attachment removes the bogus calls to BUG_ON and according to David (in CC and thanks for the long explanation on the problem) we can rely upon things like lockdep to find problem that might be trying to catch.
fs/gfs2/glock.c +0 -3
@@ -217,7 +217,6 @@ int gfs2_glock_put(struct gfs2_glock *gl)if (atomic_dec_and_test (&gl->gl_ref)) {hlist_del (&gl->gl_list);write_unlock (gl_lock_addr (gl->gl_hash)); -BUG_ON (spin_is_locked (&gl->gl_spin));gfs2_assert (sdp, gl->gl_state ==LM_ST_UNLOCKED );gfs2_assert (sdp,list_empty (&gl->gl_reclaim));gfs2_assert (sdp,list_empty (&gl->gl_holders));
@@ -460,7 +459,6 @@ static void wait_on_holder(struct gfs2_holder *gh)static void gfs2_demote_wake (struct gfs2_glock *gl) { -BUG_ON (!spin_is_locked (&gl->gl_spin)); gl->gl_demote_state =LM_ST_EXCLUSIVE ;clear_bit (GLF_DEMOTE , &gl->gl_flags);smp_mb__after_clear_bit ();
@@ -680,7 +678,6 @@ static void gfs2_glmutex_unlock(struct gfs2_glock *gl) gl->gl_owner_pid =0 ; gl->gl_ip =0 ;run_queue (gl); -BUG_ON (!spin_is_locked (&gl->gl_spin));spin_unlock (&gl->gl_spin); }
fs/gfs2/log.c +0 -2
@@ -92,8 +92,6 @@ static void gfs2_ail1_start_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai)struct buffer_head *bh;int retry; -BUG_ON (!spin_is_locked (&sdp->sd_log_lock)); - do { retry = 0;
Signature · 1 line
1.5.1.2
PATCH 26/58 Revise gfs2_logd and flush thresholds
From: Steven Whitehouse <[email protected]>
This patch intriduces two new log thresholds:
o thresh1 is the point at which we wake up gfs2_logd due to the pinned block count. It is initialised at mount time to 2/5ths of the size of the journal. Currently it does not change during the course of the mount, but the intention is to adjust it automatically based upon various conditions. This automatic adjustment will be the subject of later patches.
o thresh2 is the point at which we wake up gfs2_logd due to the total of pinned blocks and AIL blocks. It is initialised at mount time to 4/5ths of the size of the journal. The reason for not making it equal to 100% of journal size is to give gfs2_logd time to start up and do something before the processes filling the journal before they land up stalling, and waiting on journal flushes.
At the same time, the incore_log_blocks tunable is removed since it was wrong (just a basic fixed threshold set to a number plucked out of the air) and it was being compared against the wrong thing (the amount of metadata in the journal) rather than the total number of blocks.
Also, since the free blocks count is now an atomic variable, a number of these comparisons now do not need locking, so that the log lock has been removed around some operations.
This patch also ensures that there are no races when gfs2_logd is woken up. It also changes the behavour of the periodic sync so that instead of occuring every 60 secs, they will now occur every 30 secs (which can be set via /sysfs still) if there have been no other log flushes in the mean time.
When we reserve blocks at the start of a transaction, we now use a waitqueue too. This means we can remove the old mutex and the fast path through that code is just a couple of atomic operations now. Also we no longer do log flushing at this point in the code. Instead we wake up gfs2_logd to do it for us (this shouldn't happen if the log is large enough and if gfs2_logd is properly tuned) and do an exclusive wait.
As a result of these changes, postmark on my test machine runs about 20% faster, mainly due to increased efficiency in flushing the journal.
fs/gfs2/incore.h +5 -5
@@ -409,8 +409,6 @@ struct gfs2_tune {spinlock_t gt_spin;unsigned int gt_demote_secs;/* Cache retention for unheld glock */ -unsigned int gt_incore_log_blocks; -unsigned int gt_log_flush_secs;unsigned int gt_recoverd_secs;unsigned int gt_logd_secs;
@@ -542,7 +540,6 @@ struct gfs2_sbd {spinlock_t sd_jindex_spin;struct mutex sd_jindex_mutex;unsigned int sd_journals; -unsigned long sd_jindex_refresh_time;struct gfs2_jdesc *sd_jdesc;struct gfs2_holder sd_journal_gh;
@@ -583,6 +580,7 @@ struct gfs2_sbd {unsigned int sd_log_commited_databuf;unsigned int sd_log_commited_revoke; +atomic_t sd_log_pinned;unsigned int sd_log_num_buf;unsigned int sd_log_num_revoke;unsigned int sd_log_num_rg;
@@ -594,15 +592,17 @@ struct gfs2_sbd {struct list_head sd_log_le_databuf;struct list_head sd_log_le_ordered; +atomic_t sd_log_thresh1; +atomic_t sd_log_thresh2;atomic_t sd_log_blks_free; -struct mutex sd_log_reserve_mutex; +wait_queue_head_t sd_log_waitq; +wait_queue_head_t sd_logd_waitq;u64 sd_log_sequence;unsigned int sd_log_head;unsigned int sd_log_tail;int sd_log_idle; -unsigned long sd_log_flush_time;struct rw_semaphore sd_log_flush_lock;atomic_t sd_log_in_flight;wait_queue_head_t sd_log_flush_wait;
fs/gfs2/log.c +85 -61
229 lines not on this page · raw message
fs/gfs2/log.h +0 -1
@@ -49,7 +49,6 @@ unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct, unsigned int ssize);int gfs2_log_reserve (struct gfs2_sbd *sdp,unsigned int blks); -void gfs2_log_release (struct gfs2_sbd *sdp,unsigned int blks);void gfs2_log_incr_head (struct gfs2_sbd *sdp);struct buffer_head *gfs2_log_get_buf (struct gfs2_sbd *sdp);
fs/gfs2/lops.c +2 -0
@@ -52,6 +52,7 @@ static void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)if (bd->bd_ail)list_move (&bd->bd_ail_st_list, &bd->bd_ail->ai_ail2_list);get_bh (bh); +atomic_inc (&sdp->sd_log_pinned); }/**
@@ -90,6 +91,7 @@ static void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh,clear_bit (GLF_LFLUSH , &bd->bd_gl->gl_flags);gfs2_log_unlock (sdp);unlock_buffer (bh); +atomic_dec (&sdp->sd_log_pinned); }
fs/gfs2/meta_io.c +1 -0
@@ -303,6 +303,7 @@ void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, intstruct gfs2_sbd *sdp =GFS2_SB (bh->b_page->mapping->host);struct gfs2_bufdata *bd = bh->b_private;if (test_clear_buffer_pinned (bh)) { +atomic_dec (&sdp->sd_log_pinned);list_del_init (&bd->bd_le.le_list);if (meta) {gfs2_assert_warn (sdp, sdp->sd_log_num_buf);
fs/gfs2/ops_fstype.c +7 -5
@@ -76,14 +76,15 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)mutex_init (&sdp->sd_quota_mutex);spin_lock_init (&sdp->sd_log_lock); - +atomic_set (&sdp->sd_log_pinned,0 );INIT_LIST_HEAD (&sdp->sd_log_le_buf);INIT_LIST_HEAD (&sdp->sd_log_le_revoke);INIT_LIST_HEAD (&sdp->sd_log_le_rg);INIT_LIST_HEAD (&sdp->sd_log_le_databuf);INIT_LIST_HEAD (&sdp->sd_log_le_ordered); -mutex_init (&sdp->sd_log_reserve_mutex); +init_waitqueue_head (&sdp->sd_log_waitq); +init_waitqueue_head (&sdp->sd_logd_waitq);INIT_LIST_HEAD (&sdp->sd_ail1_list);INIT_LIST_HEAD (&sdp->sd_ail2_list);
@@ -340,6 +341,8 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)if (sdp->sd_args.ar_spectator) { sdp->sd_jdesc =gfs2_jdesc_find (sdp,0 );atomic_set (&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks); +atomic_set (&sdp->sd_log_thresh1,2 *sdp->sd_jdesc->jd_blocks/5 ); +atomic_set (&sdp->sd_log_thresh2,4 *sdp->sd_jdesc->jd_blocks/5 ); }else {if (sdp->sd_lockstruct.ls_jid >=gfs2_jindex_size (sdp)) { fs_err(sdp, "can't mount journal #%u\n",
@@ -377,6 +380,8 @@ static int init_journal(struct gfs2_sbd *sdp, int undo) goto fail_jinode_gh; }atomic_set (&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks); +atomic_set (&sdp->sd_log_thresh1,2 *sdp->sd_jdesc->jd_blocks/5 ); +atomic_set (&sdp->sd_log_thresh2,4 *sdp->sd_jdesc->jd_blocks/5 ); }if (sdp->sd_lockstruct.ls_first) {
@@ -608,9 +613,6 @@ static int init_threads(struct gfs2_sbd *sdp, int undo)if (undo) goto fail_quotad; - sdp->sd_log_flush_time = jiffies; - sdp->sd_jindex_refresh_time = jiffies; - p =kthread_run (gfs2_logd, sdp,"gfs2_logd" ); error =IS_ERR (p);if (error) {
fs/gfs2/super.c +1 -3
@@ -52,10 +52,8 @@ void gfs2_tune_init(struct gfs2_tune *gt)spin_lock_init (>->gt_spin); gt->gt_demote_secs =300 ; - gt->gt_incore_log_blocks =1024 ; - gt->gt_log_flush_secs =60 ; gt->gt_recoverd_secs =60 ; - gt->gt_logd_secs =1 ; + gt->gt_logd_secs =30 ; gt->gt_quotad_secs =5 ; gt->gt_quota_simul_sync =64 ; gt->gt_quota_warn_period =10 ;
fs/gfs2/sys.c +0 -4
@@ -426,8 +426,6 @@ static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\ TUNE_ATTR_2(name, name##_store)TUNE_ATTR (demote_secs,0 ); -TUNE_ATTR (incore_log_blocks,0 ); -TUNE_ATTR (log_flush_secs,0 );TUNE_ATTR (quota_warn_period,0 );TUNE_ATTR (quota_quantum,0 );TUNE_ATTR (atime_quantum,0 );
@@ -447,8 +445,6 @@ TUNE_ATTR_3(quota_scale, quota_scale_show, quota_scale_store);static struct attribute *tune_attrs[] = { &tune_attr_demote_secs.attr, - &tune_attr_incore_log_blocks.attr, - &tune_attr_log_flush_secs.attr, &tune_attr_quota_warn_period.attr, &tune_attr_quota_quantum.attr, &tune_attr_atime_quantum.attr,
fs/gfs2/trans.c +16 -0
@@ -79,6 +79,22 @@ fail_holder_uninit:return error; } +/** +* gfs2_log_release - Release a given number of log blocks +* @sdp: The GFS2 superblock +* @blks: The number of blocks +* +*/ + +static void gfs2_log_release (struct gfs2_sbd *sdp,unsigned int blks) +{ + +atomic_add (blks, &sdp->sd_log_blks_free); +gfs2_assert_withdraw (sdp,atomic_read (&sdp->sd_log_blks_free) <= + sdp->sd_jdesc->jd_blocks); +up_read (&sdp->sd_log_flush_lock); +} +void gfs2_trans_end (struct gfs2_sbd *sdp) {struct gfs2_trans *tr = current->journal_info;
Signature · 1 line
1.5.1.2
PATCH 27/58 remove unnecessary permission checks
From: Ryan O'Hara <[email protected]>
Remove read/write permission() checks from xattr operations. VFS layer is already handling permission for xattrs via the xattr_permission() call, so there is no need for gfs2 to check permissions. Futhermore, using permission() for SELinux xattrs ops is incorrect.
fs/gfs2/eaops.c +0 -30
@@ -59,9 +59,6 @@ unsigned int gfs2_ea_name2type(const char *name, const char **truncated_name)static int user_eo_get (struct gfs2_inode *ip,struct gfs2_ea_request *er) {struct inode *inode = &ip->i_inode; -int error =permission (inode,MAY_READ ,NULL ); -if (error) -return error;return gfs2_ea_get_i (ip, er); }
@@ -70,14 +67,6 @@ static int user_eo_set(struct gfs2_inode *ip, struct gfs2_ea_request *er) {struct inode *inode = &ip->i_inode; -if (S_ISREG (inode->i_mode) || - (S_ISDIR (inode->i_mode) && !(inode->i_mode &S_ISVTX ))) { -int error =permission (inode,MAY_WRITE ,NULL ); -if (error) -return error; - }else -return -EPERM ; -return gfs2_ea_set_i (ip, er); }
@@ -85,14 +74,6 @@ static int user_eo_remove(struct gfs2_inode *ip, struct gfs2_ea_request *er) {struct inode *inode = &ip->i_inode; -if (S_ISREG (inode->i_mode) || - (S_ISDIR (inode->i_mode) && !(inode->i_mode &S_ISVTX ))) { -int error =permission (inode,MAY_WRITE ,NULL ); -if (error) -return error; - }else -return -EPERM ; -return gfs2_ea_remove_i (ip, er); }
@@ -108,8 +89,6 @@ static int system_eo_get(struct gfs2_inode *ip, struct gfs2_ea_request *er) GFS2_ACL_IS_DEFAULT(er->er_name, er->er_name_len))) return -EOPNOTSUPP; - -return gfs2_ea_get_i (ip, er); }
@@ -173,9 +152,6 @@ static int system_eo_remove(struct gfs2_inode *ip, struct gfs2_ea_request *er)static int security_eo_get (struct gfs2_inode *ip,struct gfs2_ea_request *er) {struct inode *inode = &ip->i_inode; -int error =permission (inode,MAY_READ ,NULL ); -if (error) -return error;return gfs2_ea_get_i (ip, er); }
@@ -183,9 +159,6 @@ static int security_eo_get(struct gfs2_inode *ip, struct gfs2_ea_request *er)static int security_eo_set (struct gfs2_inode *ip,struct gfs2_ea_request *er) {struct inode *inode = &ip->i_inode; -int error =permission (inode,MAY_WRITE ,NULL ); -if (error) -return error;return gfs2_ea_set_i (ip, er); }
@@ -193,9 +166,6 @@ static int security_eo_set(struct gfs2_inode *ip, struct gfs2_ea_request *er)static int security_eo_remove (struct gfs2_inode *ip,struct gfs2_ea_request *er) {struct inode *inode = &ip->i_inode; -int error =permission (inode,MAY_WRITE ,NULL ); -if (error) -return error;return gfs2_ea_remove_i (ip, er); }
Signature · 1 line
1.5.1.2
PATCH 28/58 Fix build warnings
From: Fabio Massimo Di Nitto <[email protected]>
Hi Steven,
Quoted 7 lines · Steven Whitehouse
Hi,
Now in the -nmw git tree. Thanks,
Steve.
On Wed, 2007-11-21 at 11:54 -0600, Ryan O'Hara wrote:
this patch introduces a bunch of build warnings by leaving around
struct inode *inode = &ip->i_inode;
The patch in attachment cleans them up. Please apply.
fs/gfs2/eaops.c +0 -12
@@ -58,22 +58,16 @@ unsigned int gfs2_ea_name2type(const char *name, const char **truncated_name)static int user_eo_get (struct gfs2_inode *ip,struct gfs2_ea_request *er) { -struct inode *inode = &ip->i_inode; -return gfs2_ea_get_i (ip, er); }static int user_eo_set (struct gfs2_inode *ip,struct gfs2_ea_request *er) { -struct inode *inode = &ip->i_inode; -return gfs2_ea_set_i (ip, er); }static int user_eo_remove (struct gfs2_inode *ip,struct gfs2_ea_request *er) { -struct inode *inode = &ip->i_inode; -return gfs2_ea_remove_i (ip, er); }
@@ -151,22 +145,16 @@ static int system_eo_remove(struct gfs2_inode *ip, struct gfs2_ea_request *er)static int security_eo_get (struct gfs2_inode *ip,struct gfs2_ea_request *er) { -struct inode *inode = &ip->i_inode; -return gfs2_ea_get_i (ip, er); }static int security_eo_set (struct gfs2_inode *ip,struct gfs2_ea_request *er) { -struct inode *inode = &ip->i_inode; -return gfs2_ea_set_i (ip, er); }static int security_eo_remove (struct gfs2_inode *ip,struct gfs2_ea_request *er) { -struct inode *inode = &ip->i_inode; -return gfs2_ea_remove_i (ip, er); }
Signature · 1 line
1.5.1.2
PATCH 29/58 Remove unrequired code
From: Fabio M. Di Nitto <[email protected]>
fs/gfs2/eaops.c +6 -36
@@ -56,21 +56,6 @@ unsigned int gfs2_ea_name2type(const char *name, const char **truncated_name)return type; } -static int user_eo_get (struct gfs2_inode *ip,struct gfs2_ea_request *er) -{ -return gfs2_ea_get_i (ip, er); -} - -static int user_eo_set (struct gfs2_inode *ip,struct gfs2_ea_request *er) -{ -return gfs2_ea_set_i (ip, er); -} - -static int user_eo_remove (struct gfs2_inode *ip,struct gfs2_ea_request *er) -{ -return gfs2_ea_remove_i (ip, er); -} -static int system_eo_get (struct gfs2_inode *ip,struct gfs2_ea_request *er) { if (!GFS2_ACL_IS_ACCESS(er->er_name, er->er_name_len) &&
@@ -143,25 +128,10 @@ static int system_eo_remove(struct gfs2_inode *ip, struct gfs2_ea_request *er)return gfs2_ea_remove_i (ip, er); } -static int security_eo_get (struct gfs2_inode *ip,struct gfs2_ea_request *er) -{ -return gfs2_ea_get_i (ip, er); -} - -static int security_eo_set (struct gfs2_inode *ip,struct gfs2_ea_request *er) -{ -return gfs2_ea_set_i (ip, er); -} - -static int security_eo_remove (struct gfs2_inode *ip,struct gfs2_ea_request *er) -{ -return gfs2_ea_remove_i (ip, er); -} -static const struct gfs2_eattr_operations gfs2_user_eaops = { - .eo_get = user_eo_get, - .eo_set = user_eo_set, - .eo_remove = user_eo_remove, + .eo_get = gfs2_ea_get_i, + .eo_set = gfs2_ea_set_i, + .eo_remove = gfs2_ea_remove_i, .eo_name ="user" , };
@@ -173,9 +143,9 @@ const struct gfs2_eattr_operations gfs2_system_eaops = { };static const struct gfs2_eattr_operations gfs2_security_eaops = { - .eo_get = security_eo_get, - .eo_set = security_eo_set, - .eo_remove = security_eo_remove, + .eo_get = gfs2_ea_get_i, + .eo_set = gfs2_ea_set_i, + .eo_remove = gfs2_ea_remove_i, .eo_name ="security" , };
Signature · 1 line
1.5.1.2
PATCH 30/58 Remove lock methods for lock_nolock protocol
From: Wendy Cheng <[email protected]>
GFS2 supports two modes of locking - lock_nolock for single node filesystem and lock_dlm for cluster mode locking. The gfs2 lock methods are removed from file operation table for lock_nolock protocol. This would allow VFS to handle posix lock and flock logics just like other in-tree filesystems without duplication.
fs/gfs2/inode.c +9 -2
@@ -131,14 +131,21 @@ static struct inode *gfs2_iget_skip(struct super_block *sb,void gfs2_set_iop (struct inode *inode) { +struct gfs2_sbd *sdp =GFS2_SB (inode);umode_t mode = inode->i_mode;if (S_ISREG (mode)) { inode->i_op = &gfs2_file_iops; - inode->i_fop = &gfs2_file_fops; +if (sdp->sd_args.ar_localflocks) + inode->i_fop = &gfs2_file_fops_nolock; +else + inode->i_fop = &gfs2_file_fops; }else if (S_ISDIR (mode)) { inode->i_op = &gfs2_dir_iops; - inode->i_fop = &gfs2_dir_fops; +if (sdp->sd_args.ar_localflocks) + inode->i_fop = &gfs2_dir_fops_nolock; +else + inode->i_fop = &gfs2_dir_fops; }else if (S_ISLNK (mode)) { inode->i_op = &gfs2_symlink_iops; }else {
fs/gfs2/ops_file.c +24 -12
@@ -615,15 +615,6 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)if (__mandatory_lock (&ip->i_inode))return -ENOLCK ; -if (sdp->sd_args.ar_localflocks) { -if (IS_GETLK (cmd)) { -posix_test_lock (file, fl); -return 0 ; - }else { -return posix_lock_file_wait (file, fl); - } - } -if (cmd ==F_CANCELLK ) {/* Hack: */ cmd =F_SETLK ;
@@ -716,9 +707,6 @@ static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)if (__mandatory_lock (&ip->i_inode))return -ENOLCK ; -if (sdp->sd_args.ar_localflocks) -return flock_lock_file_wait (file, fl); -if (fl->fl_type ==F_UNLCK ) {do_unflock (file, fl);return 0 ;
@@ -755,3 +743,27 @@ const struct file_operations gfs2_dir_fops = { .flock = gfs2_flock, }; +const struct file_operations gfs2_file_fops_nolock = { + .llseek = gfs2_llseek, + .read = do_sync_read, + .aio_read = generic_file_aio_read, + .write = do_sync_write, + .aio_write = generic_file_aio_write, + .unlocked_ioctl = gfs2_ioctl, + .mmap = gfs2_mmap, + .open = gfs2_open, + .release = gfs2_close, + .fsync = gfs2_fsync, + .splice_read = generic_file_splice_read, + .splice_write = generic_file_splice_write, + .setlease = gfs2_setlease, +}; + +const struct file_operations gfs2_dir_fops_nolock = { + .readdir = gfs2_readdir, + .unlocked_ioctl = gfs2_ioctl, + .open = gfs2_open, + .release = gfs2_close, + .fsync = gfs2_fsync, +}; +
fs/gfs2/ops_inode.h +2 -0
@@ -18,6 +18,8 @@ extern const struct inode_operations gfs2_symlink_iops;extern const struct inode_operations gfs2_dev_iops;extern const struct file_operations gfs2_file_fops;extern const struct file_operations gfs2_dir_fops; +extern const struct file_operations gfs2_file_fops_nolock; +extern const struct file_operations gfs2_dir_fops_nolock;extern void gfs2_set_inode_flags (struct inode *inode);
Signature · 1 line
1.5.1.2
PATCH 31/58 patch to check for recursive lock requests in gfs2_rename code path
From: Abhijith Das <[email protected]>
A certain scenario in the rename code path triggers a kernel BUG() because it accidentally does recursive locking The first lock is requested to unlink an already existing inode (replacing a file) and the second lock is requested when the destination directory needs to alloc some space. It is rare that these two
events happen during the same rename call, and even more rare that these two instances try to lock the same rgrp. It is, however, possible.
https://bugzilla.redhat.com/show_bug.cgi?id=404711
fs/gfs2/rgrp.c +25 -8
@@ -1063,22 +1063,30 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)int flags =LM_FLAG_TRY ;int skipped =0 ;int loops =0 ; -int error; +int error, rg_locked;/* Try recently successful rgrps */ rgd =recent_rgrp_first (sdp, ip->i_last_rg_alloc);while (rgd) { - error =gfs2_glock_nq_init (rgd->rd_gl,LM_ST_EXCLUSIVE , -LM_FLAG_TRY , &al->al_rgd_gh); + rg_locked =0 ; + +if (gfs2_glock_is_locked_by_me (rgd->rd_gl)) { + rg_locked =1 ; + error =0 ; + }else { + error =gfs2_glock_nq_init (rgd->rd_gl,LM_ST_EXCLUSIVE , +LM_FLAG_TRY , &al->al_rgd_gh); + }switch (error) {case 0 :if (try_rgrp_fit (rgd, al)) goto out;if (rgd->rd_flags &GFS2_RDF_CHECK ) inode =try_rgrp_unlink (rgd, last_unlinked); -gfs2_glock_dq_uninit (&al->al_rgd_gh); +if (!rg_locked) +gfs2_glock_dq_uninit (&al->al_rgd_gh);if (inode)return inode; rgd =recent_rgrp_next (rgd,1 );
@@ -1098,15 +1106,23 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked) begin = rgd =forward_rgrp_get (sdp);for (;;) { - error =gfs2_glock_nq_init (rgd->rd_gl,LM_ST_EXCLUSIVE , flags, - &al->al_rgd_gh); + rg_locked =0 ; + +if (gfs2_glock_is_locked_by_me (rgd->rd_gl)) { + rg_locked =1 ; + error =0 ; + }else { + error =gfs2_glock_nq_init (rgd->rd_gl,LM_ST_EXCLUSIVE , flags, + &al->al_rgd_gh); + }switch (error) {case 0 :if (try_rgrp_fit (rgd, al)) goto out;if (rgd->rd_flags &GFS2_RDF_CHECK ) inode =try_rgrp_unlink (rgd, last_unlinked); -gfs2_glock_dq_uninit (&al->al_rgd_gh); +if (!rg_locked) +gfs2_glock_dq_uninit (&al->al_rgd_gh);if (inode)return inode;break ;
@@ -1213,7 +1229,8 @@ void gfs2_inplace_release(struct gfs2_inode *ip) al->al_line); al->al_rgd =NULL ; -gfs2_glock_dq_uninit (&al->al_rgd_gh); +if (al->al_rgd_gh.gh_gl) +gfs2_glock_dq_uninit (&al->al_rgd_gh);if (ip !=GFS2_I (sdp->sd_rindex))gfs2_glock_dq_uninit (&al->al_ri_gh); }
Signature · 1 line
1.5.1.2
PATCH 32/58 Remove unused variable
From: Steven Whitehouse <[email protected]>
fs/gfs2/ops_file.c +0 -1
@@ -700,7 +700,6 @@ static void do_unflock(struct file *file, struct file_lock *fl)static int gfs2_flock (struct file *file,int cmd,struct file_lock *fl) {struct gfs2_inode *ip =GFS2_I (file->f_mapping->host); -struct gfs2_sbd *sdp =GFS2_SB (file->f_mapping->host);if (!(fl->fl_flags &FL_FLOCK ))return -ENOLCK ;
Signature · 1 line
1.5.1.2
PATCH 33/58 use pid for plock owner for nfs clients
From: David Teigland <[email protected]>
The fl_owner is that of lockd when posix locks arrive from nfs clients, so it can't be used to distinguish between lock holders. Use fl_pid as owner instead; it's the pid of the process on the nfs client.
fs/gfs2/locking/dlm/plock.c +14 -4
@@ -89,15 +89,19 @@ int gdlm_plock(void *lockspace, struct lm_lockname *name, op->info.number = name->ln_number; op->info.start = fl->fl_start; op->info.end = fl->fl_end; - op->info.owner = (__u64 )(long ) fl->fl_owner;if (fl->fl_lmops && fl->fl_lmops->fl_grant) { +/* fl_owner is lockd which doesn't distinguish +processes on the nfs client */ + op->info.owner = (__u64 ) fl->fl_pid; xop->callback = fl->fl_lmops->fl_grant;locks_init_lock (&xop->flc);locks_copy_lock (&xop->flc, fl); xop->fl = fl; xop->file = file; - }else + }else { + op->info.owner = (__u64 )(long ) fl->fl_owner; xop->callback =NULL ; + }send_op (op);
@@ -203,7 +207,10 @@ int gdlm_punlock(void *lockspace, struct lm_lockname *name, op->info.number = name->ln_number; op->info.start = fl->fl_start; op->info.end = fl->fl_end; - op->info.owner = (__u64 )(long ) fl->fl_owner; +if (fl->fl_lmops && fl->fl_lmops->fl_grant) + op->info.owner = (__u64 ) fl->fl_pid; +else + op->info.owner = (__u64 )(long ) fl->fl_owner;send_op (op);wait_event (recv_wq, (op->done !=0 ));
@@ -242,7 +249,10 @@ int gdlm_plock_get(void *lockspace, struct lm_lockname *name, op->info.number = name->ln_number; op->info.start = fl->fl_start; op->info.end = fl->fl_end; - op->info.owner = (__u64 )(long ) fl->fl_owner; +if (fl->fl_lmops && fl->fl_lmops->fl_grant) + op->info.owner = (__u64 ) fl->fl_pid; +else + op->info.owner = (__u64 )(long ) fl->fl_owner;send_op (op);wait_event (recv_wq, (op->done !=0 ));
Signature · 1 line
1.5.1.2
PATCH 34/58 Remove function gfs2_get_block
From: Bob Peterson <[email protected]>
This patch is just a cleanup. Function gfs2_get_block() just calls function gfs2_block_map reversing the last two parameters. By reversing the parameters, gfs2_block_map() may be called directly and function gfs2_get_block may be eliminated altogether. Since this function is done for every block operation, this streamlines the code and makes it a little bit more efficient.
fs/gfs2/bmap.c +4 -4
@@ -452,8 +452,8 @@ static inline void bmap_unlock(struct inode *inode, int create)* Returns: errno */ -int gfs2_block_map (struct inode *inode,u64 lblock,int create, -struct buffer_head *bh_map) +int gfs2_block_map (struct inode *inode,sector_t lblock, +struct buffer_head *bh_map,int create) {struct gfs2_inode *ip =GFS2_I (inode);struct gfs2_sbd *sdp =GFS2_SB (inode);
@@ -559,7 +559,7 @@ int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsiBUG_ON (!new); bh.b_size =1 << (inode->i_blkbits +5 ); - ret =gfs2_block_map (inode, lblock, create, &bh); + ret =gfs2_block_map (inode, lblock, &bh, create); *extlen = bh.b_size >> inode->i_blkbits; *dblock = bh.b_blocknr;if (buffer_new (&bh))
@@ -909,7 +909,7 @@ static int gfs2_block_truncate_page(struct address_space *mapping) err =0 ;if (!buffer_mapped (bh)) { -gfs2_get_block (inode, iblock, bh,0 ); +gfs2_block_map (inode, iblock, bh,0 );/* unmapped? It's a hole - nothing to do */ if (!buffer_mapped (bh)) goto unlock;
fs/gfs2/bmap.h +1 -1
@@ -15,7 +15,7 @@ struct gfs2_inode;struct page ;int gfs2_unstuff_dinode (struct gfs2_inode *ip,struct page *page); -int gfs2_block_map (struct inode *inode,u64 lblock,int create,struct buffer_head *bh); +int gfs2_block_map (struct inode *inode,sector_t lblock,struct buffer_head *bh,int create);int gfs2_extent_map (struct inode *inode,u64 lblock,int *new,u64 *dblock,unsigned *extlen);int gfs2_truncatei (struct gfs2_inode *ip,u64 size);
fs/gfs2/log.c +1 -1
@@ -337,7 +337,7 @@ static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)struct buffer_head bh_map = { .b_state =0 , .b_blocknr =0 }; bh_map.b_size =1 << inode->i_blkbits; - error =gfs2_block_map (inode, lbn,0 , &bh_map); + error =gfs2_block_map (inode, lbn, &bh_map,0 );if (error || !bh_map.b_blocknr)printk (KERN_INFO "error=%d, dbn=%llu lbn=%u" , error, (unsigned long long )bh_map.b_blocknr, lbn);
fs/gfs2/ops_address.c +7 -23
@@ -59,22 +59,6 @@ static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page, }/** -* gfs2_get_block - Fills in a buffer head with details about a block -* @inode: The inode -* @lblock: The block number to look up -* @bh_result: The buffer head to return the result in -* @create: Non-zero if we may add block to the file -* -* Returns: errno -*/ - -int gfs2_get_block (struct inode *inode,sector_t lblock, -struct buffer_head *bh_result,int create) -{ -return gfs2_block_map (inode, lblock, create, bh_result); -} - -/** * gfs2_get_block_noalloc - Fills in a buffer head with details about a block * @inode: The inode * @lblock: The block number to look up
@@ -89,7 +73,7 @@ static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock, {int error; - error =gfs2_block_map (inode, lblock,0 , bh_result); + error =gfs2_block_map (inode, lblock, bh_result,0 );if (error)return error;if (!buffer_mapped (bh_result))
@@ -100,7 +84,7 @@ static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,static int gfs2_get_block_direct (struct inode *inode,sector_t lblock,struct buffer_head *bh_result,int create) { -return gfs2_block_map (inode, lblock,0 , bh_result); +return gfs2_block_map (inode, lblock, bh_result,0 ); }/**
@@ -504,7 +488,7 @@ static int __gfs2_readpage(void *file, struct page *page) error =stuffed_readpage (ip, page);unlock_page (page); }else { - error =mpage_readpage (page, gfs2_get_block); + error =mpage_readpage (page, gfs2_block_map); }if (unlikely (test_bit (SDF_SHUTDOWN , &sdp->sd_flags)))
@@ -598,7 +582,7 @@ int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,* Any I/O we ignore at this time will be done via readpage later. * 2. We don't handle stuffed files here we let readpage do the honours. * 3. mpage_readpages() does most of the heavy lifting in the common case. -* 4. gfs2_get_block() is relied upon to set BH_Boundary in the right places. +* 4. gfs2_block_map() is relied upon to set BH_Boundary in the right places. */ static int gfs2_readpages(struct file *file, struct address_space *mapping,
@@ -615,7 +599,7 @@ static int gfs2_readpages(struct file *file, struct address_space *mapping,if (unlikely (ret)) goto out_uninit;if (!gfs2_is_stuffed (ip)) - ret =mpage_readpages (mapping, pages, nr_pages, gfs2_get_block); + ret =mpage_readpages (mapping, pages, nr_pages, gfs2_block_map);gfs2_glock_dq (&gh); out_uninit:gfs2_holder_uninit (&gh);
@@ -710,7 +694,7 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping, } prepare_write: - error =block_prepare_write (page, from, to, gfs2_get_block); + error =block_prepare_write (page, from, to, gfs2_block_map); out:if (error ==0 )return 0 ;
@@ -923,7 +907,7 @@ static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)return 0 ;if (!gfs2_is_stuffed (ip)) - dblock =generic_block_bmap (mapping, lblock, gfs2_get_block); + dblock =generic_block_bmap (mapping, lblock, gfs2_block_map);gfs2_glock_dq_uninit (&i_gh);
fs/gfs2/ops_address.h +0 -2
@@ -14,8 +14,6 @@#include <linux/buffer_head.h> #include <linux/mm.h> -extern int gfs2_get_block (struct inode *inode,sector_t lblock, -struct buffer_head *bh_result,int create);extern int gfs2_releasepage (struct page *page,gfp_t gfp_mask); extern int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
fs/gfs2/ops_file.c +1 -1
@@ -323,7 +323,7 @@ static int gfs2_allocate_page_backing(struct page *page) do { bh.b_state = 0; bh.b_size = size; - gfs2_block_map(inode, lblock, 1, &bh); + gfs2_block_map(inode, lblock, &bh, 1); if (!buffer_mapped(&bh)) return -EIO; size -= bh.b_size;
fs/gfs2/quota.c +2 -2
@@ -276,7 +276,7 @@ static int bh_get(struct gfs2_quota_data *qd) offset = qd->qd_slot % sdp->sd_qc_per_block;; bh_map.b_size =1 << ip->i_inode.i_blkbits; - error =gfs2_block_map (&ip->i_inode, block,0 , &bh_map); + error =gfs2_block_map (&ip->i_inode, block, &bh_map,0 );if (error) goto fail; error =gfs2_meta_read (ip->i_gl, bh_map.b_blocknr,DIO_WAIT , &bh);
@@ -645,7 +645,7 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc, }if (!buffer_mapped (bh)) { -gfs2_get_block (inode, iblock, bh,1 ); +gfs2_block_map (inode, iblock, bh,1 );if (!buffer_mapped (bh)) goto unlock; }
fs/gfs2/recovery.c +1 -1
@@ -391,7 +391,7 @@ static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *hea lblock = head->lh_blkno;gfs2_replay_incr_blk (sdp, &lblock); bh_map.b_size =1 << ip->i_inode.i_blkbits; - error =gfs2_block_map (&ip->i_inode, lblock,0 , &bh_map); + error =gfs2_block_map (&ip->i_inode, lblock, &bh_map,0 );if (error)return error;if (!bh_map.b_blocknr) {
Signature · 1 line
1.5.1.2
PATCH 35/58 Fix typo in log.c
From: Steven Whitehouse <[email protected]>
An inequality was the wrong way around causing gfs2_logd to wake up too often. This fixes it.
fs/gfs2/log.c +1 -1
@@ -802,7 +802,7 @@ void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)up_read (&sdp->sd_log_flush_lock);if (atomic_read (&sdp->sd_log_pinned) >atomic_read (&sdp->sd_log_thresh1) || - ((sdp->sd_jdesc->jd_blocks -atomic_read (&sdp->sd_log_blks_free)) < + ((sdp->sd_jdesc->jd_blocks -atomic_read (&sdp->sd_log_blks_free)) >atomic_read (&sdp->sd_log_thresh2)))wake_up (&sdp->sd_logd_waitq); }
Signature · 1 line
1.5.1.2
PATCH 36/58 Journal extent mapping
From: Bob Peterson <[email protected]>
This patch saves a little time when gfs2 writes to the journals by keeping a mapping between logical and physical blocks on disk. That's better than constantly looking up indirect pointers in buffers, when the journals are several levels of indirection (which they typically are).
fs/gfs2/incore.h +10 -1
@@ -1,6 +1,6 @@/* * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. -* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. +* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions
@@ -360,8 +360,17 @@ struct gfs2_ail {u64 ai_sync_gen; }; +struct gfs2_journal_extent { +struct list_head extent_list; + +unsigned int lblock;/* First logical block */ +u64 dblock;/* First disk block */ +u64 blocks; +}; +struct gfs2_jdesc {struct list_head jd_list; +struct list_head extent_list;struct inode *jd_inode;unsigned int jd_jid;
fs/gfs2/log.c +9 -13
@@ -1,6 +1,6 @@/* * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. -* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. +* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions
@@ -332,18 +332,14 @@ retry:static u64 log_bmap (struct gfs2_sbd *sdp,unsigned int lbn) { -struct inode *inode = sdp->sd_jdesc->jd_inode; -int error; -struct buffer_head bh_map = { .b_state =0 , .b_blocknr =0 }; - - bh_map.b_size =1 << inode->i_blkbits; - error =gfs2_block_map (inode, lbn, &bh_map,0 ); -if (error || !bh_map.b_blocknr) -printk (KERN_INFO "error=%d, dbn=%llu lbn=%u" , error, - (unsigned long long )bh_map.b_blocknr, lbn); -gfs2_assert_withdraw (sdp, !error && bh_map.b_blocknr); - -return bh_map.b_blocknr; +struct gfs2_journal_extent *je; + +list_for_each_entry (je, &sdp->sd_jdesc->extent_list, extent_list) { +if (lbn >= je->lblock && lbn < je->lblock + je->blocks) +return je->dblock + lbn; + } + +return -1 ; }/**
fs/gfs2/ops_fstype.c +67 -1
91 lines not on this page · raw message
fs/gfs2/super.c +11 -2
@@ -1,6 +1,6 @@/* * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. -* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. +* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions
@@ -414,8 +414,9 @@ int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)void gfs2_jindex_free (struct gfs2_sbd *sdp) { -struct list_head list; +struct list_head list, *head;struct gfs2_jdesc *jd; +struct gfs2_journal_extent *jext;spin_lock (&sdp->sd_jindex_spin);list_add (&list, &sdp->sd_jindex_list);
@@ -425,6 +426,14 @@ void gfs2_jindex_free(struct gfs2_sbd *sdp)while (!list_empty (&list)) { jd = list_entry(list.next, struct gfs2_jdesc, jd_list); + head = &jd->extent_list; +while (!list_empty (head)) { + jext =list_entry (head->next, + struct gfs2_journal_extent, + extent_list); +list_del (&jext->extent_list); +kfree (jext); + }list_del (&jd->jd_list);iput (jd->jd_inode);kfree (jd);
Signature · 1 line
1.5.1.2
PATCH 37/58 Get rid of useless "found" variable in quota.c
From: Bob Peterson <[email protected]>
This just eliminates an unused variable from the quota code. Not likely to be a time saver.
fs/gfs2/quota.c +2 -4
@@ -1,6 +1,6 @@/* * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. -* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. +* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions
@@ -273,7 +273,7 @@ static int bh_get(struct gfs2_quota_data *qd) } block = qd->qd_slot / sdp->sd_qc_per_block; - offset = qd->qd_slot % sdp->sd_qc_per_block;; + offset = qd->qd_slot % sdp->sd_qc_per_block; bh_map.b_size =1 << ip->i_inode.i_blkbits; error =gfs2_block_map (&ip->i_inode, block, &bh_map,0 );
@@ -1016,7 +1016,6 @@ void gfs2_quota_change(struct gfs2_inode *ip, s64 change,struct gfs2_alloc *al = &ip->i_alloc;struct gfs2_quota_data *qd;unsigned int x; -unsigned int found =0 ;if (gfs2_assert_warn (GFS2_SB (&ip->i_inode), change))return ;
@@ -1029,7 +1028,6 @@ void gfs2_quota_change(struct gfs2_inode *ip, s64 change,if ((qd->qd_id == uid &&test_bit (QDF_USER , &qd->qd_flags)) || (qd->qd_id == gid && !test_bit (QDF_USER , &qd->qd_flags))) {do_qc (qd, change); - found++; } } }
Signature · 1 line
1.5.1.2
PATCH 38/58 Run through full bitmaps quicker in gfs2_bitfit
From: Bob Peterson <[email protected]>
I eliminated the passing of an unused parameter into gfs2_bitfit called rgd.
This also changes the gfs2_bitfit code that searches for free (or used) blocks. Before, the code was trying to check for bytes that indicated 4 blocks in the undesired state. The problem is, it was spending more time trying to do this than it actually was saving. This version only optimizes the case where we're looking for free blocks, and it checks a machine word at a time. So on 32-bit machines, it will check 32-bits (16 blocks) and on 64-bit machines, it will check 64-bits (32 blocks) at a time. The compiler optimizes that quite well and we save some time, especially when running through full bitmaps (like the bitmaps allocated for the journals).
There's probably a more elegant or optimized way to do this, but I haven't thought of it yet. I'm open to suggestions.
fs/gfs2/rgrp.c +29 -25
@@ -126,41 +126,46 @@ static unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd, unsigned char *buffer,* Return: the block number (bitmap buffer scope) that was found */ -static u32 gfs2_bitfit (struct gfs2_rgrpd *rgd,unsigned char *buffer, -unsigned int buflen,u32 goal, -unsigned char old_state) +static u32 gfs2_bitfit (unsigned char *buffer,unsigned int buflen,u32 goal, +unsigned char old_state) { -unsigned char *byte, *end, alloc; +unsigned char *byte;u32 blk = goal; -unsigned int bit; +unsigned int bit, bitlong; +unsigned long *plong, plong55; +static int c =0 ; byte = buffer + (goal /GFS2_NBBY ); + plong = buffer + (goal /GFS2_NBBY ); bit = (goal %GFS2_NBBY ) *GFS2_BIT_SIZE ; - end = buffer + buflen; - alloc = (old_state ==GFS2_BLKST_FREE ) ?0x55 :0 ; - -while (byte < end) { -/* If we're looking for a free block we can eliminate all -bitmap settings with 0x55, which represents four data -blocks in a row. If we're looking for a data block, we can -eliminate 0x00 which corresponds to four free blocks. */ -if ((*byte &0x55 ) == alloc) { - blk += (8 - bit) >>1 ; - - bit =0 ; - byte++; - + bitlong = bit; +#if BITS_PER_LONG ==32 + plong55 =0x55555555 ; +#else + plong55 =0x5555555555555555 ; +#endif +while (byte < buffer + buflen) { + +if (bitlong ==0 && old_state ==0 && *plong == plong55) { + plong++; + byte +=sizeof (unsigned long ); + blk +=sizeof (unsigned long ) *GFS2_NBBY ;continue ; } - -if (((*byte >> bit) &GFS2_BIT_MASK ) == old_state) +if (((*byte >> bit) &GFS2_BIT_MASK ) == old_state) { + c++;return blk; - + } bit +=GFS2_BIT_SIZE ;if (bit >=8 ) { bit =0 ; byte++; } + bitlong +=GFS2_BIT_SIZE ; +if (bitlong >=sizeof (unsigned long ) *8 ) { + bitlong =0 ; + plong++; + } blk++; }
@@ -1318,11 +1323,10 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,/* The GFS2_BLKST_UNLINKED state doesn't apply to the clone bitmaps, so we must search the originals for that. */ if (old_state !=GFS2_BLKST_UNLINKED && bi->bi_clone) - blk =gfs2_bitfit (rgd, bi->bi_clone + bi->bi_offset, + blk =gfs2_bitfit (bi->bi_clone + bi->bi_offset, bi->bi_len, goal, old_state);else - blk =gfs2_bitfit (rgd, - bi->bi_bh->b_data + bi->bi_offset, + blk =gfs2_bitfit (bi->bi_bh->b_data + bi->bi_offset, bi->bi_len, goal, old_state);if (blk !=BFITNOENT )break ;
Signature · 1 line
1.5.1.2
PATCH 39/58 Reorganize function gfs2_glmutex_lock
From: Bob Peterson <[email protected]>
This patch optimizes the function gfs2_glmutex_lock.
The basic theory is: Why bother initializing a holder, setting up wait bits and then waiting on them, if you know the glock can be yours. So the holder stuff is placed inside the if checking if the glock is locked. This one needs careful scrutiny because changing anything to do with locking should strike terror into one's heart.
fs/gfs2/glock.c +9 -14
@@ -1,6 +1,6 @@/* * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. -* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. +* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions
@@ -620,26 +620,21 @@ static void run_queue(struct gfs2_glock *gl)static void gfs2_glmutex_lock (struct gfs2_glock *gl) { -struct gfs2_holder gh; - -gfs2_holder_init (gl,0 ,0 , &gh); -if (test_and_set_bit (HIF_WAIT , &gh.gh_iflags)) -BUG (); -spin_lock (&gl->gl_spin);if (test_and_set_bit (GLF_LOCK , &gl->gl_flags)) { +struct gfs2_holder gh; + +gfs2_holder_init (gl,0 ,0 , &gh); +set_bit (HIF_WAIT , &gh.gh_iflags);list_add_tail (&gh.gh_list, &gl->gl_waiters1); +spin_unlock (&gl->gl_spin); +wait_on_holder (&gh); +gfs2_holder_uninit (&gh); }else { gl->gl_owner_pid = current->pid; gl->gl_ip = (unsigned long )__builtin_return_address (0 ); -clear_bit (HIF_WAIT , &gh.gh_iflags); -smp_mb (); -wake_up_bit (&gh.gh_iflags,HIF_WAIT ); +spin_unlock (&gl->gl_spin); } -spin_unlock (&gl->gl_spin); - -wait_on_holder (&gh); -gfs2_holder_uninit (&gh); }/**
Signature · 1 line
1.5.1.2
PATCH 40/58 Only fetch the dinode once in block_map
From: Bob Peterson <[email protected]>
Function gfs2_block_map was often looking up the disk inode twice. This optimizes it so that only does it once.
fs/gfs2/bmap.c +7 -7
@@ -469,6 +469,7 @@ int gfs2_block_map(struct inode *inode, sector_t lblock,unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;struct metapath mp;u64 size; +struct buffer_head *dibh =NULL ;BUG_ON (maxlen ==0 );
@@ -499,6 +500,8 @@ int gfs2_block_map(struct inode *inode, sector_t lblock, error =gfs2_meta_inode_buffer (ip, &bh);if (error) goto out_fail; + dibh = bh; +get_bh (dibh);for (x =0 ; x < end_of_metadata; x++) {lookup_block (ip, bh, x, &mp, create, &new, &dblock);
@@ -517,13 +520,8 @@ int gfs2_block_map(struct inode *inode, sector_t lblock,if (boundary)set_buffer_boundary (bh_map);if (new) { -struct buffer_head *dibh; - error =gfs2_meta_inode_buffer (ip, &dibh); -if (!error) { -gfs2_trans_add_bh (ip->i_gl, dibh,1 ); -gfs2_dinode_out (ip, dibh->b_data); -brelse (dibh); - } +gfs2_trans_add_bh (ip->i_gl, dibh,1 ); +gfs2_dinode_out (ip, dibh->b_data);set_buffer_new (bh_map); goto out_brelse; }
@@ -544,6 +542,8 @@ out_brelse: out_ok: error =0 ; out_fail: +if (dibh) +brelse (dibh);bmap_unlock (inode, create);return error; }
Signature · 1 line
1.5.1.2
PATCH 41/58 Function meta_read optimization
From: Bob Peterson <[email protected]>
This patch optimizes function gfs2_meta_read. Basically, gfs2_meta_wait was being called regardless of whether a disk read was requested. This just pulls that wait into the if that triggers the read.
fs/gfs2/meta_io.c +7 -6
@@ -222,13 +222,14 @@ int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags, struct buffer_head **bhp) { *bhp =getbuf (gl, blkno,CREATE ); -if (!buffer_uptodate (*bhp)) +if (!buffer_uptodate (*bhp)) {ll_rw_block (READ_META ,1 , bhp); -if (flags &DIO_WAIT ) { -int error =gfs2_meta_wait (gl->gl_sbd, *bhp); -if (error) { -brelse (*bhp); -return error; +if (flags &DIO_WAIT ) { +int error =gfs2_meta_wait (gl->gl_sbd, *bhp); +if (error) { +brelse (*bhp); +return error; + } } }
Signature · 1 line
1.5.1.2
PATCH 42/58 Incremental patch to fix compiler warning
From: Bob Peterson <[email protected]>
fs/gfs2/rgrp.c +2 -5
@@ -133,10 +133,9 @@ static u32 gfs2_bitfit(unsigned char *buffer, unsigned int buflen, u32 goal,u32 blk = goal;unsigned int bit, bitlong;unsigned long *plong, plong55; -static int c =0 ; byte = buffer + (goal /GFS2_NBBY ); - plong = buffer + (goal /GFS2_NBBY ); + plong = (unsigned long *)(buffer + (goal /GFS2_NBBY )); bit = (goal %GFS2_NBBY ) *GFS2_BIT_SIZE ; bitlong = bit;#if BITS_PER_LONG ==32
@@ -152,10 +151,8 @@ static u32 gfs2_bitfit(unsigned char *buffer, unsigned int buflen, u32 goal, blk +=sizeof (unsigned long ) *GFS2_NBBY ;continue ; } -if (((*byte >> bit) &GFS2_BIT_MASK ) == old_state) { - c++; +if (((*byte >> bit) &GFS2_BIT_MASK ) == old_state)return blk; - } bit +=GFS2_BIT_SIZE ;if (bit >=8 ) { bit =0 ;
Signature · 1 line
1.5.1.2
PATCH 43/58 Eliminate the no longer needed sd_statfs_mutex
From: Bob Peterson <[email protected]>
This patch eliminates the unneeded sd_statfs_mutex mutex but preserves the ordering as discussed.
fs/gfs2/incore.h +0 -1
@@ -527,7 +527,6 @@ struct gfs2_sbd {/* StatFS stuff */ spinlock_t sd_statfs_spin; -struct mutex sd_statfs_mutex;struct gfs2_statfs_change_host sd_statfs_master;struct gfs2_statfs_change_host sd_statfs_local;unsigned long sd_statfs_sync_time;
fs/gfs2/ops_fstype.c +0 -1
@@ -60,7 +60,6 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)mutex_init (&sdp->sd_inum_mutex);spin_lock_init (&sdp->sd_statfs_spin); -mutex_init (&sdp->sd_statfs_mutex);spin_lock_init (&sdp->sd_rindex_spin);mutex_init (&sdp->sd_rindex_mutex);
fs/gfs2/super.c +0 -4
@@ -686,9 +686,7 @@ void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,if (error)return ; -mutex_lock (&sdp->sd_statfs_mutex);gfs2_trans_add_bh (l_ip->i_gl, l_bh,1 ); -mutex_unlock (&sdp->sd_statfs_mutex);spin_lock (&sdp->sd_statfs_spin); l_sc->sc_total += total;
@@ -736,9 +734,7 @@ int gfs2_statfs_sync(struct gfs2_sbd *sdp)if (error) goto out_bh2; -mutex_lock (&sdp->sd_statfs_mutex);gfs2_trans_add_bh (l_ip->i_gl, l_bh,1 ); -mutex_unlock (&sdp->sd_statfs_mutex);spin_lock (&sdp->sd_statfs_spin); m_sc->sc_total += l_sc->sc_total;
Signature · 1 line
1.5.1.2
PATCH 44/58 Minor correction
From: Bob Peterson <[email protected]>
This is a small correction to my previously posted patch1. It just changes a divide to a shift. It's faster and doesn't introduce odd dependencies on 32-bit compiles.
fs/gfs2/ops_fstype.c +1 -1
@@ -333,7 +333,7 @@ static int map_journal_extents(struct gfs2_sbd *sdp)INIT_LIST_HEAD (&jd->extent_list); prev_db =0 ; -for (lb =0 ; lb < ip->i_di.di_size / sdp->sd_sb.sb_bsize; lb++) { +for (lb =0 ; lb < ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift; lb++) { bh.b_state =0 ; bh.b_blocknr =0 ; bh.b_size =1 << ip->i_inode.i_blkbits;
Signature · 1 line
1.5.1.2
PATCH 45/58 Fix log block mapper
From: Steven Whitehouse <[email protected]>
A missing offset in the calculation.
fs/gfs2/log.c +1 -1
@@ -336,7 +336,7 @@ static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)list_for_each_entry (je, &sdp->sd_jdesc->extent_list, extent_list) {if (lbn >= je->lblock && lbn < je->lblock + je->blocks) -return je->dblock + lbn; +return je->dblock + lbn - je->lblock; }return -1 ;
Signature · 1 line
1.5.1.2
PATCH 46/58 Remove unused variable
From: Steven Whitehouse <[email protected]>
The go_drop_th function is never called or referenced.
fs/gfs2/incore.h +0 -1
@@ -131,7 +131,6 @@ struct gfs2_bufdata {struct gfs2_glock_operations {void (*go_xmote_th) (struct gfs2_glock *gl);void (*go_xmote_bh) (struct gfs2_glock *gl); -void (*go_drop_th) (struct gfs2_glock *gl);void (*go_inval) (struct gfs2_glock *gl,int flags);int (*go_demote_ok) (struct gfs2_glock *gl);int (*go_lock) (struct gfs2_holder *gh);
Signature · 1 line
1.5.1.2
PATCH 47/58 Allow page migration for writeback and ordered pages
From: Steven Whitehouse <[email protected]>
To improve performance on NUMA, we use the VM's standard page migration for writeback and ordered pages. Probably we could also do the same for journaled data, but that would need a careful audit of the code, so will be the subject of a later patch.
fs/gfs2/ops_address.c +2 -0
@@ -1098,6 +1098,7 @@ static const struct address_space_operations gfs2_writeback_aops = { .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage, .direct_IO = gfs2_direct_IO, + .migratepage = buffer_migrate_page, };static const struct address_space_operations gfs2_ordered_aops = {
@@ -1112,6 +1113,7 @@ static const struct address_space_operations gfs2_ordered_aops = { .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage, .direct_IO = gfs2_direct_IO, + .migratepage = buffer_migrate_page, };static const struct address_space_operations gfs2_jdata_aops = {
Signature · 1 line
1.5.1.2
PATCH 48/58 Initialize extent_list earlier
From: Bob Peterson <[email protected]>
Here is a patch for the latest upstream GFS2 code:
The journal extent map needs to be initialized sooner than it currently is. Otherwise failed mount attempts (e.g. not enough journals, etc.) may panic trying to access the uninitialized list.
fs/gfs2/ops_fstype.c +0 -1
@@ -330,7 +330,6 @@ static int map_journal_extents(struct gfs2_sbd *sdp)struct buffer_head bh;int rc =0 ; -INIT_LIST_HEAD (&jd->extent_list); prev_db =0 ;for (lb =0 ; lb < ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift; lb++) {
fs/gfs2/super.c +1 -0
@@ -385,6 +385,7 @@ int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)if (!jd)break ; +INIT_LIST_HEAD (&jd->extent_list); jd->jd_inode =gfs2_lookupi (sdp->sd_jindex, &name,1 ,NULL );if (!jd->jd_inode ||IS_ERR (jd->jd_inode)) {if (!jd->jd_inode)
Signature · 1 line
1.5.1.2
PATCH 49/58 Fix problems relating to execution of files on GFS2
From: Steven Whitehouse <[email protected]>
This patch fixes a couple of problems which affected the execution of files on GFS2. The first is that there was a corner case where inodes were not always uptodate at the point at which permissions checks were being carried out, this was resulting in refusal of execute permission, but only on the first lookup, subsequent requests worked correctly. The second was a problem relating to incorrect updating of file sizes which was introduced with the write_begin/end code for GFS2 a little while back.
fs/gfs2/ops_address.c +5 -8
@@ -848,14 +848,11 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping, ret =generic_write_end (file, mapping, pos, len, copied, page, fsdata); -if (likely (ret >=0 )) { - copied = ret; -if ((pos + copied) > inode->i_size) { - di = (struct gfs2_dinode *)dibh->b_data; - ip->i_di.di_size = inode->i_size; - di->di_size =cpu_to_be64 (inode->i_size); -mark_inode_dirty (inode); - } +if (likely (ret >=0 ) && (inode->i_size > ip->i_di.di_size)) { + di = (struct gfs2_dinode *)dibh->b_data; + ip->i_di.di_size = inode->i_size; + di->di_size =cpu_to_be64 (inode->i_size); +mark_inode_dirty (inode); }if (inode == sdp->sd_rindex)
fs/gfs2/ops_inode.c +11 -1
@@ -113,8 +113,18 @@ static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,if (inode &&IS_ERR (inode))return ERR_PTR (PTR_ERR (inode)); -if (inode) +if (inode) { +struct gfs2_glock *gl =GFS2_I (inode)->i_gl; +struct gfs2_holder gh; +int error; + error =gfs2_glock_nq_init (gl,LM_ST_SHARED ,LM_FLAG_ANY , &gh); +if (error) { +iput (inode); +return ERR_PTR (error); + } +gfs2_glock_dq_uninit (&gh);return d_splice_alias (inode, dentry); + }d_add (dentry, inode);return NULL ;
Signature · 1 line
1.5.1.2
PATCH 50/58 Fix assert in log code
From: Steven Whitehouse <[email protected]>
Although the values were all being calculated correctly, there was a race in the assert due to the way it was using atomic variables. This changes the value we assert on so that we get the same effect by testing a different variable. This prevents the assert triggering when it shouldn't.
fs/gfs2/log.c +4 -7
@@ -749,7 +749,7 @@ void __gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl)static void log_refund (struct gfs2_sbd *sdp,struct gfs2_trans *tr) {unsigned int reserved; -unsigned int old; +unsigned int unused;gfs2_log_lock (sdp);
@@ -761,14 +761,11 @@ static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr) sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;gfs2_assert_withdraw (sdp, ((int )sdp->sd_log_commited_revoke) >=0 ); reserved =calc_reserved (sdp); - old =atomic_read (&sdp->sd_log_blks_free); -atomic_add (tr->tr_reserved - (reserved - sdp->sd_log_blks_reserved), - &sdp->sd_log_blks_free); - -gfs2_assert_withdraw (sdp,atomic_read (&sdp->sd_log_blks_free) >= old); + unused = sdp->sd_log_blks_reserved - reserved + tr->tr_reserved; +gfs2_assert_withdraw (sdp, unused >=0 ); +atomic_add (unused, &sdp->sd_log_blks_free);gfs2_assert_withdraw (sdp,atomic_read (&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks); - sdp->sd_log_blks_reserved = reserved;gfs2_log_unlock (sdp);
Signature · 1 line
1.5.1.2
PATCH 51/58 Reduce inode size by moving i_alloc out of line
From: Steven Whitehouse <[email protected]>
It is possible to reduce the size of GFS2 inodes by taking the i_alloc structure out of the gfs2_inode. This patch allocates the i_alloc structure whenever its needed, and frees it afterward. This decreases the amount of low memory we use at the expense of requiring a memory allocation for each page or partial page that we write. A quick test with postmark shows that the overhead is not measurable and I also note that OCFS2 use the same approach.
In the future I'd like to solve the problem by shrinking down the size of the members of the i_alloc structure, but for now, this reduces the immediate problem of using too much low-memory on x86 and doesn't add too much overhead.
fs/gfs2/bmap.c +2 -2
@@ -683,7 +683,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,if (metadata) revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs; - error =gfs2_rindex_hold (sdp, &ip->i_alloc.al_ri_gh); + error =gfs2_rindex_hold (sdp, &ip->i_alloc->al_ri_gh);if (error)return error;
@@ -785,7 +785,7 @@ out_rg_gunlock: out_rlist:gfs2_rlist_free (&rlist); out: -gfs2_glock_dq_uninit (&ip->i_alloc.al_ri_gh); +gfs2_glock_dq_uninit (&ip->i_alloc->al_ri_gh);return error; }
fs/gfs2/dir.c +2 -2
@@ -1876,7 +1876,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,if (error) goto out; - error =gfs2_rindex_hold (sdp, &dip->i_alloc.al_ri_gh); + error =gfs2_rindex_hold (sdp, &dip->i_alloc->al_ri_gh);if (error) goto out_qs;
@@ -1949,7 +1949,7 @@ out_rg_gunlock:gfs2_glock_dq_m (rlist.rl_rgrps, rlist.rl_ghs); out_rlist:gfs2_rlist_free (&rlist); -gfs2_glock_dq_uninit (&dip->i_alloc.al_ri_gh); +gfs2_glock_dq_uninit (&dip->i_alloc->al_ri_gh); out_qs:gfs2_quota_unhold (dip); out:
fs/gfs2/eattr.c +1 -1
@@ -1418,7 +1418,7 @@ out:static int ea_dealloc_block (struct gfs2_inode *ip) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_rgrpd *rgd;struct buffer_head *dibh;int error;
fs/gfs2/incore.h +1 -1
@@ -264,7 +264,7 @@ struct gfs2_inode {struct gfs2_glock *i_gl;/* Move into i_gh? */ struct gfs2_holder i_iopen_gh;struct gfs2_holder i_gh;/* for prepare/commit_write only */ -struct gfs2_alloc i_alloc; +struct gfs2_alloc *i_alloc;u64 i_last_rg_alloc;spinlock_t i_spin;
fs/gfs2/inode.c +4 -3
@@ -711,9 +711,10 @@ static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)struct gfs2_sbd *sdp =GFS2_SB (&dip->i_inode);int error; -gfs2_alloc_get (dip); +if (gfs2_alloc_get (dip) ==NULL ) +return -ENOMEM ; - dip->i_alloc.al_requested =RES_DINODE ; + dip->i_alloc->al_requested =RES_DINODE ; error =gfs2_inplace_reserve (dip);if (error) goto out;
@@ -900,7 +901,7 @@ fail_end_trans:gfs2_trans_end (sdp); fail_ipreserv: -if (dip->i_alloc.al_rgd) +if (dip->i_alloc->al_rgd)gfs2_inplace_release (dip); fail_quota_locks:
fs/gfs2/main.c +1 -0
@@ -31,6 +31,7 @@ static void gfs2_init_inode_once(struct kmem_cache *cachep, void *foo)inode_init_once (&ip->i_inode);spin_lock_init (&ip->i_spin);init_rwsem (&ip->i_rw_mutex); + ip->i_alloc =NULL ; }static void gfs2_init_glock_once (struct kmem_cache *cachep,void *foo)
fs/gfs2/ops_address.c +2 -3
@@ -646,7 +646,6 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping,if (error) goto out_unlock; - ip->i_alloc.al_requested =0 ;if (alloc_required) { al =gfs2_alloc_get (ip);
@@ -823,7 +822,7 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping,struct gfs2_inode *ip =GFS2_I (inode);struct gfs2_sbd *sdp =GFS2_SB (inode);struct buffer_head *dibh; -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_dinode *di;unsigned int from = pos & (PAGE_CACHE_SIZE -1 );unsigned int to = from + len;
@@ -861,7 +860,7 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping,brelse (dibh);gfs2_trans_end (sdp); failed: -if (al->al_requested) { +if (al) {gfs2_inplace_release (ip);gfs2_quota_unlock (ip);gfs2_alloc_put (ip);
fs/gfs2/ops_file.c +4 -2
@@ -364,9 +364,11 @@ static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct page *page) ret =gfs2_write_alloc_required (ip, pos,PAGE_CACHE_SIZE , &alloc_required);if (ret || !alloc_required) goto out_unlock; - - ip->i_alloc.al_requested =0 ; + ret = -ENOMEM ; al =gfs2_alloc_get (ip); +if (al ==NULL ) + goto out_unlock; + ret =gfs2_quota_lock (ip,NO_QUOTA_CHANGE ,NO_QUOTA_CHANGE );if (ret) goto out_alloc_put;
fs/gfs2/ops_inode.c +4 -4
@@ -61,7 +61,7 @@ static int gfs2_create(struct inode *dir, struct dentry *dentry, inode =gfs2_createi (ghs, &dentry->d_name,S_IFREG | mode,0 );if (!IS_ERR (inode)) {gfs2_trans_end (sdp); -if (dip->i_alloc.al_rgd) +if (dip->i_alloc->al_rgd)gfs2_inplace_release (dip);gfs2_quota_unlock (dip);gfs2_alloc_put (dip);
@@ -376,7 +376,7 @@ static int gfs2_symlink(struct inode *dir, struct dentry *dentry, }gfs2_trans_end (sdp); -if (dip->i_alloc.al_rgd) +if (dip->i_alloc->al_rgd)gfs2_inplace_release (dip);gfs2_quota_unlock (dip);gfs2_alloc_put (dip);
@@ -452,7 +452,7 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)gfs2_assert_withdraw (sdp, !error);/* dip already pinned */ gfs2_trans_end (sdp); -if (dip->i_alloc.al_rgd) +if (dip->i_alloc->al_rgd)gfs2_inplace_release (dip);gfs2_quota_unlock (dip);gfs2_alloc_put (dip);
@@ -558,7 +558,7 @@ static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode, }gfs2_trans_end (sdp); -if (dip->i_alloc.al_rgd) +if (dip->i_alloc->al_rgd)gfs2_inplace_release (dip);gfs2_quota_unlock (dip);gfs2_alloc_put (dip);
fs/gfs2/quota.c +6 -6
@@ -453,7 +453,7 @@ static void qdsb_put(struct gfs2_quota_data *qd)int gfs2_quota_hold (struct gfs2_inode *ip,u32 uid,u32 gid) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_quota_data **qd = al->al_qd;int error;
@@ -501,7 +501,7 @@ out:void gfs2_quota_unhold (struct gfs2_inode *ip) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;unsigned int x;gfs2_assert_warn (sdp, !test_bit (GIF_QD_LOCKED , &ip->i_flags));
@@ -853,7 +853,7 @@ fail:int gfs2_quota_lock (struct gfs2_inode *ip,u32 uid,u32 gid) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;unsigned int x;int error =0 ;
@@ -921,7 +921,7 @@ static int need_sync(struct gfs2_quota_data *qd)void gfs2_quota_unlock (struct gfs2_inode *ip) { -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_quota_data *qda[4 ];unsigned int count =0 ;unsigned int x;
@@ -969,7 +969,7 @@ static int print_message(struct gfs2_quota_data *qd, char *type)int gfs2_quota_check (struct gfs2_inode *ip,u32 uid,u32 gid) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_quota_data *qd;s64 value;unsigned int x;
@@ -1013,7 +1013,7 @@ int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid)void gfs2_quota_change (struct gfs2_inode *ip,s64 change,u32 uid,u32 gid) { -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_quota_data *qd;unsigned int x;
fs/gfs2/rgrp.c +9 -11
@@ -819,11 +819,9 @@ void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)struct gfs2_alloc *gfs2_alloc_get (struct gfs2_inode *ip) { -struct gfs2_alloc *al = &ip->i_alloc; - -/* FIXME: Should assert that the correct locks are held here... */ -memset (al,0 ,sizeof (*al)); -return al; +BUG_ON (ip->i_alloc !=NULL ); + ip->i_alloc =kzalloc (sizeof (struct gfs2_alloc ),GFP_KERNEL ); +return ip->i_alloc; }/**
@@ -1061,7 +1059,7 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)struct inode *inode =NULL ;struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode);struct gfs2_rgrpd *rgd, *begin =NULL ; -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;int flags =LM_FLAG_TRY ;int skipped =0 ;int loops =0 ;
@@ -1176,7 +1174,7 @@ out:int gfs2_inplace_reserve_i (struct gfs2_inode *ip,char *file,unsigned int line) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct inode *inode;int error =0 ;u64 last_unlinked =NO_BLOCK ;
@@ -1222,7 +1220,7 @@ try_again:void gfs2_inplace_release (struct gfs2_inode *ip) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;if (gfs2_assert_warn (sdp, al->al_alloced <= al->al_requested) ==-1 ) fs_warn(sdp, "al_alloced = %u, al_requested = %u "
@@ -1412,7 +1410,7 @@ static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,u64 gfs2_alloc_data (struct gfs2_inode *ip) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_rgrpd *rgd = al->al_rgd;u32 goal, blk;u64 block;
@@ -1457,7 +1455,7 @@ u64 gfs2_alloc_data(struct gfs2_inode *ip)u64 gfs2_alloc_meta (struct gfs2_inode *ip) {struct gfs2_sbd *sdp =GFS2_SB (&ip->i_inode); -struct gfs2_alloc *al = &ip->i_alloc; +struct gfs2_alloc *al = ip->i_alloc;struct gfs2_rgrpd *rgd = al->al_rgd;u32 goal, blk;u64 block;
@@ -1503,7 +1501,7 @@ u64 gfs2_alloc_meta(struct gfs2_inode *ip)u64 gfs2_alloc_di (struct gfs2_inode *dip,u64 *generation) {struct gfs2_sbd *sdp =GFS2_SB (&dip->i_inode); -struct gfs2_alloc *al = &dip->i_alloc; +struct gfs2_alloc *al = dip->i_alloc;struct gfs2_rgrpd *rgd = al->al_rgd;u32 blk;u64 block;
fs/gfs2/rgrp.h +3 -1
@@ -32,7 +32,9 @@ void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd);struct gfs2_alloc *gfs2_alloc_get (struct gfs2_inode *ip);static inline void gfs2_alloc_put (struct gfs2_inode *ip) { -return ;/* So we can see where ip->i_alloc is used */ +BUG_ON (ip->i_alloc ==NULL ); +kfree (ip->i_alloc); + ip->i_alloc =NULL ; } int gfs2_inplace_reserve_i(struct gfs2_inode *ip,
Signature · 1 line
1.5.1.2
PATCH 52/58 Remove unneeded i_spin
From: Bob Peterson <[email protected]>
This patch removes a vestigial variable "i_spin" from the gfs2_inode structure. This not only saves us memory (>300000 of these in memory for the oom test) it also saves us time because we don't have to spend time initializing it (i.e. slightly better performance).
fs/gfs2/incore.h +0 -1
@@ -267,7 +267,6 @@ struct gfs2_inode {struct gfs2_alloc *i_alloc;u64 i_last_rg_alloc; -spinlock_t i_spin;struct rw_semaphore i_rw_mutex; };
fs/gfs2/main.c +0 -1
@@ -29,7 +29,6 @@ static void gfs2_init_inode_once(struct kmem_cache *cachep, void *foo)struct gfs2_inode *ip = foo;inode_init_once (&ip->i_inode); -spin_lock_init (&ip->i_spin);init_rwsem (&ip->i_rw_mutex); ip->i_alloc =NULL ; }
Signature · 1 line
1.5.1.2
PATCH 53/58 gfs2_alloc_required performance
From: Bob Peterson <[email protected]>
This is a small I/O performance enhancement to gfs2. (Actually, it is a rework of an earlier version I got wrong). The idea here is to check if the write extends past the last block in the file. If so, the function can save itself a lot of time and trouble because it knows an allocate will be required. Benchmarks like iozone should see better performance.
fs/gfs2/bmap.c +5 -0
@@ -1224,6 +1224,11 @@ int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,unsigned int shift = sdp->sd_sb.sb_bsize_shift; lblock = offset >> shift; lblock_stop = (offset + len + sdp->sd_sb.sb_bsize -1 ) >> shift; +if (lblock_stop > ip->i_di.di_blocks) {/* writing past the +last block */ + *alloc_required =1 ; +return 0 ; + } }for (; lblock < lblock_stop; lblock += extlen) {
Signature · 1 line
1.5.1.2
PATCH 54/58 Fix write alloc required shortcut calculation
From: Steven Whitehouse <[email protected]>
The comparison was being made against the wrong quantity.
fs/gfs2/bmap.c +2 -2
@@ -1222,10 +1222,10 @@ int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,do_div (lblock_stop, bsize); }else {unsigned int shift = sdp->sd_sb.sb_bsize_shift; +u64 end_of_file = (ip->i_di.di_size + sdp->sd_sb.sb_bsize -1 ) >> shift; lblock = offset >> shift; lblock_stop = (offset + len + sdp->sd_sb.sb_bsize -1 ) >> shift; -if (lblock_stop > ip->i_di.di_blocks) {/* writing past the -last block */ +if (lblock_stop > end_of_file) { *alloc_required =1 ;return 0 ; }
Signature · 1 line
1.5.1.2
PATCH 55/58 Fix typo
From: Bob Peterson <[email protected]>
This patch fixes a minor typo. Surprisingly, it still compiled.
fs/gfs2/meta_io.c +1 -1
@@ -284,7 +284,7 @@ void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,return ; } - bd =kmem_cache_zalloc (gfs2_bufdata_cachep,GFP_NOFS | __GFP_NOFAIL), + bd =kmem_cache_zalloc (gfs2_bufdata_cachep,GFP_NOFS | __GFP_NOFAIL); bd->bd_bh = bh; bd->bd_gl = gl;
Signature · 1 line
1.5.1.2
PATCH 56/58 Fix page_mkwrite truncation race path
From: Steven Whitehouse <[email protected]>
There was a bug in the truncation/invalidation race path for ->page_mkwrite for gfs2. It ought to return 0 so that the effect is the same as if the page was truncated at any of the other points at which the page_lock is dropped. This will result in the restart of the whole page fault path. If it was due to a real truncation (as opposed to an invalidate because we let a glock go) then the ->fault path will pick that up when it gets called again.
fs/gfs2/ops_file.c +1 -0
@@ -394,6 +394,7 @@ static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct page *page) last_index = ip->i_inode.i_size >>PAGE_CACHE_SHIFT ;if (page->index > last_index) goto out_unlock_page; + ret =0 ;if (!PageUptodate (page) || page->mapping != ip->i_inode.i_mapping) goto out_unlock_page;if (gfs2_is_stuffed (ip)) {
Signature · 1 line
1.5.1.2
PATCH 57/58 Lockup on error
From: Bob Peterson <[email protected]>
I spotted this bug while I was digging around. Looks like it could cause a lockup in some rare error condition.
fs/gfs2/inode.c +1 -1
@@ -860,7 +860,7 @@ static int link_dinode(struct gfs2_inode *dip, const struct qstr *name, error = alloc_required =gfs2_diradd_alloc_required (&dip->i_inode, name);if (alloc_required <0 ) - goto fail; + goto fail_quota_locks;if (alloc_required) { error =gfs2_quota_check (dip, dip->i_inode.i_uid, dip->i_inode.i_gid);if (error)
Signature · 1 line
1.5.1.2
PATCH 58/58 Allow journal recovery on read-only mount
From: Abhijith Das <[email protected]>
This patch allows gfs2 to perform journal recovery even if it is mounted read-only. Strictly speaking, a read-only mount should not be writing to the filesystem, but we do this only to perform journal recovery. A read-only mount will fail if we don't recover the dirty journal. Also, when gfs2 is used as a root filesystem, it will be mounted read-only before being mounted read-write during the boot sequence. A failed read-only mount will panic the machine during bootup.
fs/gfs2/recovery.c +12 -4
@@ -504,13 +504,21 @@ int gfs2_recover_journal(struct gfs2_jdesc *jd)if (!test_bit (SDF_JOURNAL_LIVE , &sdp->sd_flags)) ro =1 ; }else { -if (sdp->sd_vfs->s_flags &MS_RDONLY ) - ro =1 ; +if (sdp->sd_vfs->s_flags &MS_RDONLY ) { +/* check if device itself is read-only */ + ro =bdev_read_only (sdp->sd_vfs->s_bdev); +if (!ro) { +fs_info (sdp,"recovery required on " +"read-only filesystem.\n" ); +fs_info (sdp,"write access will be " +"enabled during recovery.\n" ); + } + } }if (ro) { -fs_warn (sdp,"jid=%u: Can't replay: read-only FS\n" , - jd->jd_jid); +fs_warn (sdp,"jid=%u: Can't replay: read-only block " +"device\n" , jd->jd_jid); error = -EROFS ; goto fail_gunlock_tr; }
Signature · 1 line
1.5.1.2
A message that is not in the archive (sent off-list or not yet received): be5784b198847d5cdfa103c6882383c11eb6d7d2.1200905287.git.swhiteho@redhat.com
PATCH 26/58 Revise gfs2_logd and flush thresholds
Quoted 42 lines · swhiteho at redhat.com
From: Steven Whitehouse <[email protected]>
This patch intriduces two new log thresholds:
o thresh1 is the point at which we wake up
gfs2_logddue to the pinned block count. It is initialised at mount time to 2/5ths of the size of the journal. Currently it does not change during the course of the mount, but the intention is to adjust it automatically based upon various conditions. This automatic adjustment will be the subject of later patches.o thresh2 is the point at which we wake up
gfs2_logddue to the total of pinned blocks and AIL blocks. It is initialised at mount time to 4/5ths of the size of the journal. The reason for not making it equal to 100% of journal size is to givegfs2_logdtime to start up and do something before the processes filling the journal before they land up stalling, and waiting on journal flushes.At the same time, the
incore_log_blockstunable is removed since it was wrong (just a basic fixed threshold set to a number plucked out of the air) and it was being compared against the wrong thing (the amount of metadata in the journal) rather than the total number of blocks.Also, since the free blocks count is now an atomic variable, a number of these comparisons now do not need locking, so that the log lock has been removed around some operations.
This patch also ensures that there are no races when
gfs2_logdis woken up. It also changes the behavour of the periodic sync so that instead of occuring every 60 secs, they will now occur every 30 secs (which can be set via /sysfs still) if there have been no other log flushes in the mean time.When we reserve blocks at the start of a transaction, we now use a waitqueue too. This means we can remove the old mutex and the fast path through that code is just a couple of atomic operations now. Also we no longer do log flushing at this point in the code. Instead we wake up
gfs2_logdto do it for us (this shouldn't happen if the log is large enough and ifgfs2_logdis properly tuned) and do an exclusive wait.
Quoted 4 lines
As a result of these changes, postmark on my test machine runs about 20% faster, mainly due to increased efficiency in flushing the journal.
Steve,
I still think this one is a bad idea. Postmark might be 20% faster, but every other benchmark we have run shows this causes significant I/O delays and poor performance. It also changes the interface between users space utilities and the filesystem.
Kevin
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://listman.redhat.com/archives/cluster-devel/attachments/20080121/4203716f/attachment.htm>