Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw
* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw: GFS2: Fix typo GFS2: stuck in inode wait, no glocks stuck GFS2: Eliminate useless err variable GFS2: Fix writing to non-page aligned gfs2_quota structures GFS2: Add some useful messages GFS2: fix quota state reporting GFS2: Various gfs2_logd improvements GFS2: glock livelock GFS2: Clean up stuffed file copying GFS2: docs update GFS2: Remove space from slab cache name
This commit is contained in:
Linus Torvalds
Коммит
677abe49ad
|
|
@ -1,7 +1,7 @@
|
|||
Global File System
|
||||
------------------
|
||||
|
||||
http://sources.redhat.com/cluster/
|
||||
http://sources.redhat.com/cluster/wiki/
|
||||
|
||||
GFS is a cluster file system. It allows a cluster of computers to
|
||||
simultaneously use a block device that is shared between them (with FC,
|
||||
|
|
@ -36,11 +36,11 @@ GFS2 is not on-disk compatible with previous versions of GFS, but it
|
|||
is pretty close.
|
||||
|
||||
The following man pages can be found at the URL above:
|
||||
fsck.gfs2 to repair a filesystem
|
||||
gfs2_grow to expand a filesystem online
|
||||
gfs2_jadd to add journals to a filesystem online
|
||||
gfs2_tool to manipulate, examine and tune a filesystem
|
||||
fsck.gfs2 to repair a filesystem
|
||||
gfs2_grow to expand a filesystem online
|
||||
gfs2_jadd to add journals to a filesystem online
|
||||
gfs2_tool to manipulate, examine and tune a filesystem
|
||||
gfs2_quota to examine and change quota values in a filesystem
|
||||
gfs2_convert to convert a gfs filesystem to gfs2 in-place
|
||||
mount.gfs2 to help mount(8) mount a filesystem
|
||||
mkfs.gfs2 to make a filesystem
|
||||
mkfs.gfs2 to make a filesystem
|
||||
|
|
|
|||
|
|
@ -418,6 +418,7 @@ static int gfs2_jdata_writepages(struct address_space *mapping,
|
|||
static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
|
||||
{
|
||||
struct buffer_head *dibh;
|
||||
u64 dsize = i_size_read(&ip->i_inode);
|
||||
void *kaddr;
|
||||
int error;
|
||||
|
||||
|
|
@ -437,9 +438,10 @@ static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
|
|||
return error;
|
||||
|
||||
kaddr = kmap_atomic(page, KM_USER0);
|
||||
memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
|
||||
ip->i_disksize);
|
||||
memset(kaddr + ip->i_disksize, 0, PAGE_CACHE_SIZE - ip->i_disksize);
|
||||
if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
|
||||
dsize = (dibh->b_size - sizeof(struct gfs2_dinode));
|
||||
memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
|
||||
memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);
|
||||
kunmap_atomic(kaddr, KM_USER0);
|
||||
flush_dcache_page(page);
|
||||
brelse(dibh);
|
||||
|
|
|
|||
|
|
@ -71,11 +71,13 @@ static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
|
|||
|
||||
if (!PageUptodate(page)) {
|
||||
void *kaddr = kmap(page);
|
||||
u64 dsize = i_size_read(inode);
|
||||
|
||||
if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
|
||||
dsize = dibh->b_size - sizeof(struct gfs2_dinode);
|
||||
|
||||
memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
|
||||
ip->i_disksize);
|
||||
memset(kaddr + ip->i_disksize, 0,
|
||||
PAGE_CACHE_SIZE - ip->i_disksize);
|
||||
memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
|
||||
memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);
|
||||
kunmap(page);
|
||||
|
||||
SetPageUptodate(page);
|
||||
|
|
@ -1038,13 +1040,14 @@ static int trunc_start(struct gfs2_inode *ip, u64 size)
|
|||
goto out;
|
||||
|
||||
if (gfs2_is_stuffed(ip)) {
|
||||
ip->i_disksize = size;
|
||||
u64 dsize = size + sizeof(struct gfs2_inode);
|
||||
ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
|
||||
gfs2_trans_add_bh(ip->i_gl, dibh, 1);
|
||||
gfs2_dinode_out(ip, dibh->b_data);
|
||||
gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + size);
|
||||
if (dsize > dibh->b_size)
|
||||
dsize = dibh->b_size;
|
||||
gfs2_buffer_clear_tail(dibh, dsize);
|
||||
error = 1;
|
||||
|
||||
} else {
|
||||
if (size & (u64)(sdp->sd_sb.sb_bsize - 1))
|
||||
error = gfs2_block_truncate_page(ip->i_inode.i_mapping);
|
||||
|
|
|
|||
|
|
@ -1475,7 +1475,7 @@ struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
|
|||
inode = gfs2_inode_lookup(dir->i_sb,
|
||||
be16_to_cpu(dent->de_type),
|
||||
be64_to_cpu(dent->de_inum.no_addr),
|
||||
be64_to_cpu(dent->de_inum.no_formal_ino), 0);
|
||||
be64_to_cpu(dent->de_inum.no_formal_ino));
|
||||
brelse(bh);
|
||||
return inode;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ static struct dentry *gfs2_get_dentry(struct super_block *sb,
|
|||
if (error)
|
||||
goto fail;
|
||||
|
||||
inode = gfs2_inode_lookup(sb, DT_UNKNOWN, inum->no_addr, 0, 0);
|
||||
inode = gfs2_inode_lookup(sb, DT_UNKNOWN, inum->no_addr, 0);
|
||||
if (IS_ERR(inode)) {
|
||||
error = PTR_ERR(inode);
|
||||
goto fail;
|
||||
|
|
|
|||
|
|
@ -855,6 +855,9 @@ void gfs2_holder_reinit(unsigned int state, unsigned flags, struct gfs2_holder *
|
|||
gh->gh_flags = flags;
|
||||
gh->gh_iflags = 0;
|
||||
gh->gh_ip = (unsigned long)__builtin_return_address(0);
|
||||
if (gh->gh_owner_pid)
|
||||
put_pid(gh->gh_owner_pid);
|
||||
gh->gh_owner_pid = get_pid(task_pid(current));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -439,9 +439,6 @@ struct gfs2_args {
|
|||
struct gfs2_tune {
|
||||
spinlock_t gt_spin;
|
||||
|
||||
unsigned int gt_incore_log_blocks;
|
||||
unsigned int gt_log_flush_secs;
|
||||
|
||||
unsigned int gt_logd_secs;
|
||||
|
||||
unsigned int gt_quota_simul_sync; /* Max quotavals to sync at once */
|
||||
|
|
@ -462,6 +459,7 @@ enum {
|
|||
SDF_SHUTDOWN = 2,
|
||||
SDF_NOBARRIERS = 3,
|
||||
SDF_NORECOVERY = 4,
|
||||
SDF_DEMOTE = 5,
|
||||
};
|
||||
|
||||
#define GFS2_FSNAME_LEN 256
|
||||
|
|
@ -618,6 +616,7 @@ struct gfs2_sbd {
|
|||
unsigned int sd_log_commited_databuf;
|
||||
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;
|
||||
|
|
@ -629,15 +628,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;
|
||||
|
|
|
|||
101
fs/gfs2/inode.c
101
fs/gfs2/inode.c
|
|
@ -158,7 +158,6 @@ void gfs2_set_iop(struct inode *inode)
|
|||
* @sb: The super block
|
||||
* @no_addr: The inode number
|
||||
* @type: The type of the inode
|
||||
* @skip_freeing: set this not return an inode if it is currently being freed.
|
||||
*
|
||||
* Returns: A VFS inode, or an error
|
||||
*/
|
||||
|
|
@ -166,17 +165,14 @@ void gfs2_set_iop(struct inode *inode)
|
|||
struct inode *gfs2_inode_lookup(struct super_block *sb,
|
||||
unsigned int type,
|
||||
u64 no_addr,
|
||||
u64 no_formal_ino, int skip_freeing)
|
||||
u64 no_formal_ino)
|
||||
{
|
||||
struct inode *inode;
|
||||
struct gfs2_inode *ip;
|
||||
struct gfs2_glock *io_gl;
|
||||
int error;
|
||||
|
||||
if (skip_freeing)
|
||||
inode = gfs2_iget_skip(sb, no_addr);
|
||||
else
|
||||
inode = gfs2_iget(sb, no_addr);
|
||||
inode = gfs2_iget(sb, no_addr);
|
||||
ip = GFS2_I(inode);
|
||||
|
||||
if (!inode)
|
||||
|
|
@ -233,12 +229,99 @@ fail_glock:
|
|||
gfs2_glock_dq(&ip->i_iopen_gh);
|
||||
fail_iopen:
|
||||
gfs2_glock_put(io_gl);
|
||||
fail_put:
|
||||
if (inode->i_state & I_NEW)
|
||||
ip->i_gl->gl_object = NULL;
|
||||
gfs2_glock_put(ip->i_gl);
|
||||
fail:
|
||||
if (inode->i_state & I_NEW)
|
||||
iget_failed(inode);
|
||||
else
|
||||
iput(inode);
|
||||
return ERR_PTR(error);
|
||||
}
|
||||
|
||||
/**
|
||||
* gfs2_unlinked_inode_lookup - Lookup an unlinked inode for reclamation
|
||||
* @sb: The super block
|
||||
* no_addr: The inode number
|
||||
* @@inode: A pointer to the inode found, if any
|
||||
*
|
||||
* Returns: 0 and *inode if no errors occurred. If an error occurs,
|
||||
* the resulting *inode may or may not be NULL.
|
||||
*/
|
||||
|
||||
int gfs2_unlinked_inode_lookup(struct super_block *sb, u64 no_addr,
|
||||
struct inode **inode)
|
||||
{
|
||||
struct gfs2_sbd *sdp;
|
||||
struct gfs2_inode *ip;
|
||||
struct gfs2_glock *io_gl;
|
||||
int error;
|
||||
struct gfs2_holder gh;
|
||||
|
||||
*inode = gfs2_iget_skip(sb, no_addr);
|
||||
|
||||
if (!(*inode))
|
||||
return -ENOBUFS;
|
||||
|
||||
if (!((*inode)->i_state & I_NEW))
|
||||
return -ENOBUFS;
|
||||
|
||||
ip = GFS2_I(*inode);
|
||||
sdp = GFS2_SB(*inode);
|
||||
ip->i_no_formal_ino = -1;
|
||||
|
||||
error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
|
||||
if (unlikely(error))
|
||||
goto fail;
|
||||
ip->i_gl->gl_object = ip;
|
||||
|
||||
error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
|
||||
if (unlikely(error))
|
||||
goto fail_put;
|
||||
|
||||
set_bit(GIF_INVALID, &ip->i_flags);
|
||||
error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, LM_FLAG_TRY | GL_EXACT,
|
||||
&ip->i_iopen_gh);
|
||||
if (unlikely(error)) {
|
||||
if (error == GLR_TRYFAILED)
|
||||
error = 0;
|
||||
goto fail_iopen;
|
||||
}
|
||||
ip->i_iopen_gh.gh_gl->gl_object = ip;
|
||||
gfs2_glock_put(io_gl);
|
||||
|
||||
(*inode)->i_mode = DT2IF(DT_UNKNOWN);
|
||||
|
||||
/*
|
||||
* We must read the inode in order to work out its type in
|
||||
* this case. Note that this doesn't happen often as we normally
|
||||
* know the type beforehand. This code path only occurs during
|
||||
* unlinked inode recovery (where it is safe to do this glock,
|
||||
* which is not true in the general case).
|
||||
*/
|
||||
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, LM_FLAG_TRY,
|
||||
&gh);
|
||||
if (unlikely(error)) {
|
||||
if (error == GLR_TRYFAILED)
|
||||
error = 0;
|
||||
goto fail_glock;
|
||||
}
|
||||
/* Inode is now uptodate */
|
||||
gfs2_glock_dq_uninit(&gh);
|
||||
gfs2_set_iop(*inode);
|
||||
|
||||
return 0;
|
||||
fail_glock:
|
||||
gfs2_glock_dq(&ip->i_iopen_gh);
|
||||
fail_iopen:
|
||||
gfs2_glock_put(io_gl);
|
||||
fail_put:
|
||||
ip->i_gl->gl_object = NULL;
|
||||
gfs2_glock_put(ip->i_gl);
|
||||
fail:
|
||||
iget_failed(inode);
|
||||
return ERR_PTR(error);
|
||||
return error;
|
||||
}
|
||||
|
||||
static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
|
||||
|
|
@ -862,7 +945,7 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
|
|||
goto fail_gunlock2;
|
||||
|
||||
inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,
|
||||
inum.no_formal_ino, 0);
|
||||
inum.no_formal_ino);
|
||||
if (IS_ERR(inode))
|
||||
goto fail_gunlock2;
|
||||
|
||||
|
|
|
|||
|
|
@ -83,8 +83,9 @@ static inline void gfs2_inum_out(const struct gfs2_inode *ip,
|
|||
|
||||
extern void gfs2_set_iop(struct inode *inode);
|
||||
extern struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned type,
|
||||
u64 no_addr, u64 no_formal_ino,
|
||||
int skip_freeing);
|
||||
u64 no_addr, u64 no_formal_ino);
|
||||
extern int gfs2_unlinked_inode_lookup(struct super_block *sb, u64 no_addr,
|
||||
struct inode **inode);
|
||||
extern struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr);
|
||||
|
||||
extern int gfs2_inode_refresh(struct gfs2_inode *ip);
|
||||
|
|
|
|||
160
fs/gfs2/log.c
160
fs/gfs2/log.c
|
|
@ -168,12 +168,11 @@ static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai, int fl
|
|||
return list_empty(&ai->ai_ail1_list);
|
||||
}
|
||||
|
||||
static void gfs2_ail1_start(struct gfs2_sbd *sdp, int flags)
|
||||
static void gfs2_ail1_start(struct gfs2_sbd *sdp)
|
||||
{
|
||||
struct list_head *head;
|
||||
u64 sync_gen;
|
||||
struct list_head *first;
|
||||
struct gfs2_ail *first_ai, *ai, *tmp;
|
||||
struct gfs2_ail *ai;
|
||||
int done = 0;
|
||||
|
||||
gfs2_log_lock(sdp);
|
||||
|
|
@ -184,21 +183,9 @@ static void gfs2_ail1_start(struct gfs2_sbd *sdp, int flags)
|
|||
}
|
||||
sync_gen = sdp->sd_ail_sync_gen++;
|
||||
|
||||
first = head->prev;
|
||||
first_ai = list_entry(first, struct gfs2_ail, ai_list);
|
||||
first_ai->ai_sync_gen = sync_gen;
|
||||
gfs2_ail1_start_one(sdp, first_ai); /* This may drop log lock */
|
||||
|
||||
if (flags & DIO_ALL)
|
||||
first = NULL;
|
||||
|
||||
while(!done) {
|
||||
if (first && (head->prev != first ||
|
||||
gfs2_ail1_empty_one(sdp, first_ai, 0)))
|
||||
break;
|
||||
|
||||
done = 1;
|
||||
list_for_each_entry_safe_reverse(ai, tmp, head, ai_list) {
|
||||
list_for_each_entry_reverse(ai, head, ai_list) {
|
||||
if (ai->ai_sync_gen >= sync_gen)
|
||||
continue;
|
||||
ai->ai_sync_gen = sync_gen;
|
||||
|
|
@ -290,58 +277,57 @@ static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
|
|||
* flush time, so we ensure that we have just enough free blocks at all
|
||||
* times to avoid running out during a log flush.
|
||||
*
|
||||
* We no longer flush the log here, instead we wake up logd to do that
|
||||
* for us. To avoid the thundering herd and to ensure that we deal fairly
|
||||
* with queued waiters, we use an exclusive wait. This means that when we
|
||||
* get woken with enough journal space to get our reservation, we need to
|
||||
* wake the next waiter on the list.
|
||||
*
|
||||
* Returns: errno
|
||||
*/
|
||||
|
||||
int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
|
||||
{
|
||||
unsigned int try = 0;
|
||||
unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize);
|
||||
unsigned wanted = blks + reserved_blks;
|
||||
DEFINE_WAIT(wait);
|
||||
int did_wait = 0;
|
||||
unsigned int free_blocks;
|
||||
|
||||
if (gfs2_assert_warn(sdp, blks) ||
|
||||
gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks))
|
||||
return -EINVAL;
|
||||
|
||||
mutex_lock(&sdp->sd_log_reserve_mutex);
|
||||
gfs2_log_lock(sdp);
|
||||
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);
|
||||
|
||||
if (try++)
|
||||
gfs2_ail1_start(sdp, 0);
|
||||
gfs2_log_lock(sdp);
|
||||
retry:
|
||||
free_blocks = atomic_read(&sdp->sd_log_blks_free);
|
||||
if (unlikely(free_blocks <= wanted)) {
|
||||
do {
|
||||
prepare_to_wait_exclusive(&sdp->sd_log_waitq, &wait,
|
||||
TASK_UNINTERRUPTIBLE);
|
||||
wake_up(&sdp->sd_logd_waitq);
|
||||
did_wait = 1;
|
||||
if (atomic_read(&sdp->sd_log_blks_free) <= wanted)
|
||||
io_schedule();
|
||||
free_blocks = atomic_read(&sdp->sd_log_blks_free);
|
||||
} while(free_blocks <= wanted);
|
||||
finish_wait(&sdp->sd_log_waitq, &wait);
|
||||
}
|
||||
atomic_sub(blks, &sdp->sd_log_blks_free);
|
||||
if (atomic_cmpxchg(&sdp->sd_log_blks_free, free_blocks,
|
||||
free_blocks - blks) != free_blocks)
|
||||
goto retry;
|
||||
trace_gfs2_log_blocks(sdp, -blks);
|
||||
gfs2_log_unlock(sdp);
|
||||
mutex_unlock(&sdp->sd_log_reserve_mutex);
|
||||
|
||||
/*
|
||||
* If we waited, then so might others, wake them up _after_ we get
|
||||
* our share of the log.
|
||||
*/
|
||||
if (unlikely(did_wait))
|
||||
wake_up(&sdp->sd_log_waitq);
|
||||
|
||||
down_read(&sdp->sd_log_flush_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* gfs2_log_release - Release a given number of log blocks
|
||||
* @sdp: The GFS2 superblock
|
||||
* @blks: The number of blocks
|
||||
*
|
||||
*/
|
||||
|
||||
void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
|
||||
{
|
||||
|
||||
gfs2_log_lock(sdp);
|
||||
atomic_add(blks, &sdp->sd_log_blks_free);
|
||||
trace_gfs2_log_blocks(sdp, blks);
|
||||
gfs2_assert_withdraw(sdp,
|
||||
atomic_read(&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);
|
||||
gfs2_log_unlock(sdp);
|
||||
up_read(&sdp->sd_log_flush_lock);
|
||||
}
|
||||
|
||||
static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)
|
||||
{
|
||||
struct gfs2_journal_extent *je;
|
||||
|
|
@ -559,11 +545,10 @@ static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail)
|
|||
|
||||
ail2_empty(sdp, new_tail);
|
||||
|
||||
gfs2_log_lock(sdp);
|
||||
atomic_add(dist, &sdp->sd_log_blks_free);
|
||||
trace_gfs2_log_blocks(sdp, dist);
|
||||
gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);
|
||||
gfs2_log_unlock(sdp);
|
||||
gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
|
||||
sdp->sd_jdesc->jd_blocks);
|
||||
|
||||
sdp->sd_log_tail = new_tail;
|
||||
}
|
||||
|
|
@ -615,6 +600,7 @@ static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull)
|
|||
if (buffer_eopnotsupp(bh)) {
|
||||
clear_buffer_eopnotsupp(bh);
|
||||
set_buffer_uptodate(bh);
|
||||
fs_info(sdp, "barrier sync failed - disabling barriers\n");
|
||||
set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
|
||||
lock_buffer(bh);
|
||||
skip_barrier:
|
||||
|
|
@ -822,6 +808,13 @@ static void buf_lo_incore_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
|
|||
* @sdp: the filesystem
|
||||
* @tr: the transaction
|
||||
*
|
||||
* We wake up gfs2_logd if the number of pinned blocks exceed thresh1
|
||||
* or the total number of used blocks (pinned blocks plus AIL blocks)
|
||||
* is greater than thresh2.
|
||||
*
|
||||
* At mount time thresh1 is 1/3rd of journal size, thresh2 is 2/3rd of
|
||||
* journal size.
|
||||
*
|
||||
* Returns: errno
|
||||
*/
|
||||
|
||||
|
|
@ -832,10 +825,10 @@ void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
|
|||
|
||||
up_read(&sdp->sd_log_flush_lock);
|
||||
|
||||
gfs2_log_lock(sdp);
|
||||
if (sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks))
|
||||
wake_up_process(sdp->sd_logd_process);
|
||||
gfs2_log_unlock(sdp);
|
||||
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)) >
|
||||
atomic_read(&sdp->sd_log_thresh2)))
|
||||
wake_up(&sdp->sd_logd_waitq);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -882,13 +875,23 @@ void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
|
|||
{
|
||||
gfs2_log_flush(sdp, NULL);
|
||||
for (;;) {
|
||||
gfs2_ail1_start(sdp, DIO_ALL);
|
||||
gfs2_ail1_start(sdp);
|
||||
if (gfs2_ail1_empty(sdp, DIO_ALL))
|
||||
break;
|
||||
msleep(10);
|
||||
}
|
||||
}
|
||||
|
||||
static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
|
||||
{
|
||||
return (atomic_read(&sdp->sd_log_pinned) >= atomic_read(&sdp->sd_log_thresh1));
|
||||
}
|
||||
|
||||
static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp)
|
||||
{
|
||||
unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free);
|
||||
return used_blocks >= atomic_read(&sdp->sd_log_thresh2);
|
||||
}
|
||||
|
||||
/**
|
||||
* gfs2_logd - Update log tail as Active Items get flushed to in-place blocks
|
||||
|
|
@ -901,28 +904,43 @@ void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
|
|||
int gfs2_logd(void *data)
|
||||
{
|
||||
struct gfs2_sbd *sdp = data;
|
||||
unsigned long t;
|
||||
int need_flush;
|
||||
unsigned long t = 1;
|
||||
DEFINE_WAIT(wait);
|
||||
unsigned preflush;
|
||||
|
||||
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)) {
|
||||
preflush = atomic_read(&sdp->sd_log_pinned);
|
||||
if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
|
||||
gfs2_ail1_empty(sdp, DIO_ALL);
|
||||
gfs2_log_flush(sdp, NULL);
|
||||
sdp->sd_log_flush_time = jiffies;
|
||||
gfs2_ail1_empty(sdp, DIO_ALL);
|
||||
}
|
||||
|
||||
if (gfs2_ail_flush_reqd(sdp)) {
|
||||
gfs2_ail1_start(sdp);
|
||||
io_schedule();
|
||||
gfs2_ail1_empty(sdp, 0);
|
||||
gfs2_log_flush(sdp, NULL);
|
||||
gfs2_ail1_empty(sdp, DIO_ALL);
|
||||
}
|
||||
|
||||
wake_up(&sdp->sd_log_waitq);
|
||||
t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
|
||||
if (freezing(current))
|
||||
refrigerator();
|
||||
schedule_timeout_interruptible(t);
|
||||
|
||||
do {
|
||||
prepare_to_wait(&sdp->sd_logd_waitq, &wait,
|
||||
TASK_UNINTERRUPTIBLE);
|
||||
if (!gfs2_ail_flush_reqd(sdp) &&
|
||||
!gfs2_jrnl_flush_reqd(sdp) &&
|
||||
!kthread_should_stop())
|
||||
t = schedule_timeout(t);
|
||||
} while(t && !gfs2_ail_flush_reqd(sdp) &&
|
||||
!gfs2_jrnl_flush_reqd(sdp) &&
|
||||
!kthread_should_stop());
|
||||
finish_wait(&sdp->sd_logd_waitq, &wait);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -51,7 +51,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);
|
||||
|
|
|
|||
|
|
@ -54,6 +54,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);
|
||||
trace_gfs2_pin(bd, 1);
|
||||
}
|
||||
|
||||
|
|
@ -94,6 +95,7 @@ static void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh,
|
|||
trace_gfs2_pin(bd, 0);
|
||||
gfs2_log_unlock(sdp);
|
||||
unlock_buffer(bh);
|
||||
atomic_dec(&sdp->sd_log_pinned);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ static int __init init_gfs2_fs(void)
|
|||
if (!gfs2_glock_cachep)
|
||||
goto fail;
|
||||
|
||||
gfs2_glock_aspace_cachep = kmem_cache_create("gfs2_glock (aspace)",
|
||||
gfs2_glock_aspace_cachep = kmem_cache_create("gfs2_glock(aspace)",
|
||||
sizeof(struct gfs2_glock) +
|
||||
sizeof(struct address_space),
|
||||
0, 0, gfs2_init_gl_aspace_once);
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@
|
|||
|
||||
static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wbc)
|
||||
{
|
||||
int err;
|
||||
struct buffer_head *bh, *head;
|
||||
int nr_underway = 0;
|
||||
int write_op = (1 << BIO_RW_META) | ((wbc->sync_mode == WB_SYNC_ALL ?
|
||||
|
|
@ -86,11 +85,10 @@ static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wb
|
|||
} while (bh != head);
|
||||
unlock_page(page);
|
||||
|
||||
err = 0;
|
||||
if (nr_underway == 0)
|
||||
end_page_writeback(page);
|
||||
|
||||
return err;
|
||||
return 0;
|
||||
}
|
||||
|
||||
const struct address_space_operations gfs2_meta_aops = {
|
||||
|
|
@ -313,6 +311,7 @@ void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int
|
|||
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);
|
||||
|
|
|
|||
|
|
@ -57,8 +57,6 @@ static void gfs2_tune_init(struct gfs2_tune *gt)
|
|||
{
|
||||
spin_lock_init(>->gt_spin);
|
||||
|
||||
gt->gt_incore_log_blocks = 1024;
|
||||
gt->gt_logd_secs = 1;
|
||||
gt->gt_quota_simul_sync = 64;
|
||||
gt->gt_quota_warn_period = 10;
|
||||
gt->gt_quota_scale_num = 1;
|
||||
|
|
@ -101,14 +99,15 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)
|
|||
spin_lock_init(&sdp->sd_trunc_lock);
|
||||
|
||||
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);
|
||||
|
||||
|
|
@ -487,7 +486,7 @@ static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
|
|||
struct dentry *dentry;
|
||||
struct inode *inode;
|
||||
|
||||
inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
|
||||
inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0);
|
||||
if (IS_ERR(inode)) {
|
||||
fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
|
||||
return PTR_ERR(inode);
|
||||
|
|
@ -733,6 +732,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",
|
||||
|
|
@ -770,6 +771,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);
|
||||
|
||||
/* Map the extents for this journal's blocks */
|
||||
map_journal_extents(sdp);
|
||||
|
|
@ -951,8 +954,6 @@ static int init_threads(struct gfs2_sbd *sdp, int undo)
|
|||
if (undo)
|
||||
goto fail_quotad;
|
||||
|
||||
sdp->sd_log_flush_time = jiffies;
|
||||
|
||||
p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
|
||||
error = IS_ERR(p);
|
||||
if (error) {
|
||||
|
|
@ -1160,7 +1161,7 @@ static int fill_super(struct super_block *sb, struct gfs2_args *args, int silent
|
|||
GFS2_BASIC_BLOCK_SHIFT;
|
||||
sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
|
||||
|
||||
sdp->sd_tune.gt_log_flush_secs = sdp->sd_args.ar_commit;
|
||||
sdp->sd_tune.gt_logd_secs = sdp->sd_args.ar_commit;
|
||||
sdp->sd_tune.gt_quota_quantum = sdp->sd_args.ar_quota_quantum;
|
||||
if (sdp->sd_args.ar_statfs_quantum) {
|
||||
sdp->sd_tune.gt_statfs_slow = 0;
|
||||
|
|
@ -1323,7 +1324,7 @@ static int gfs2_get_sb(struct file_system_type *fs_type, int flags,
|
|||
memset(&args, 0, sizeof(args));
|
||||
args.ar_quota = GFS2_QUOTA_DEFAULT;
|
||||
args.ar_data = GFS2_DATA_DEFAULT;
|
||||
args.ar_commit = 60;
|
||||
args.ar_commit = 30;
|
||||
args.ar_statfs_quantum = 30;
|
||||
args.ar_quota_quantum = 60;
|
||||
args.ar_errors = GFS2_ERRORS_DEFAULT;
|
||||
|
|
|
|||
102
fs/gfs2/quota.c
102
fs/gfs2/quota.c
|
|
@ -637,15 +637,40 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
|
|||
unsigned blocksize, iblock, pos;
|
||||
struct buffer_head *bh, *dibh;
|
||||
struct page *page;
|
||||
void *kaddr;
|
||||
struct gfs2_quota *qp;
|
||||
s64 value;
|
||||
int err = -EIO;
|
||||
void *kaddr, *ptr;
|
||||
struct gfs2_quota q, *qp;
|
||||
int err, nbytes;
|
||||
u64 size;
|
||||
|
||||
if (gfs2_is_stuffed(ip))
|
||||
gfs2_unstuff_dinode(ip, NULL);
|
||||
|
||||
|
||||
memset(&q, 0, sizeof(struct gfs2_quota));
|
||||
err = gfs2_internal_read(ip, NULL, (char *)&q, &loc, sizeof(q));
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
err = -EIO;
|
||||
qp = &q;
|
||||
qp->qu_value = be64_to_cpu(qp->qu_value);
|
||||
qp->qu_value += change;
|
||||
qp->qu_value = cpu_to_be64(qp->qu_value);
|
||||
qd->qd_qb.qb_value = qp->qu_value;
|
||||
if (fdq) {
|
||||
if (fdq->d_fieldmask & FS_DQ_BSOFT) {
|
||||
qp->qu_warn = cpu_to_be64(fdq->d_blk_softlimit);
|
||||
qd->qd_qb.qb_warn = qp->qu_warn;
|
||||
}
|
||||
if (fdq->d_fieldmask & FS_DQ_BHARD) {
|
||||
qp->qu_limit = cpu_to_be64(fdq->d_blk_hardlimit);
|
||||
qd->qd_qb.qb_limit = qp->qu_limit;
|
||||
}
|
||||
}
|
||||
|
||||
/* Write the quota into the quota file on disk */
|
||||
ptr = qp;
|
||||
nbytes = sizeof(struct gfs2_quota);
|
||||
get_a_page:
|
||||
page = grab_cache_page(mapping, index);
|
||||
if (!page)
|
||||
return -ENOMEM;
|
||||
|
|
@ -667,7 +692,12 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
|
|||
if (!buffer_mapped(bh)) {
|
||||
gfs2_block_map(inode, iblock, bh, 1);
|
||||
if (!buffer_mapped(bh))
|
||||
goto unlock;
|
||||
goto unlock_out;
|
||||
/* If it's a newly allocated disk block for quota, zero it */
|
||||
if (buffer_new(bh)) {
|
||||
memset(bh->b_data, 0, bh->b_size);
|
||||
set_buffer_uptodate(bh);
|
||||
}
|
||||
}
|
||||
|
||||
if (PageUptodate(page))
|
||||
|
|
@ -677,32 +707,34 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
|
|||
ll_rw_block(READ_META, 1, &bh);
|
||||
wait_on_buffer(bh);
|
||||
if (!buffer_uptodate(bh))
|
||||
goto unlock;
|
||||
goto unlock_out;
|
||||
}
|
||||
|
||||
gfs2_trans_add_bh(ip->i_gl, bh, 0);
|
||||
|
||||
kaddr = kmap_atomic(page, KM_USER0);
|
||||
qp = kaddr + offset;
|
||||
value = (s64)be64_to_cpu(qp->qu_value) + change;
|
||||
qp->qu_value = cpu_to_be64(value);
|
||||
qd->qd_qb.qb_value = qp->qu_value;
|
||||
if (fdq) {
|
||||
if (fdq->d_fieldmask & FS_DQ_BSOFT) {
|
||||
qp->qu_warn = cpu_to_be64(fdq->d_blk_softlimit);
|
||||
qd->qd_qb.qb_warn = qp->qu_warn;
|
||||
}
|
||||
if (fdq->d_fieldmask & FS_DQ_BHARD) {
|
||||
qp->qu_limit = cpu_to_be64(fdq->d_blk_hardlimit);
|
||||
qd->qd_qb.qb_limit = qp->qu_limit;
|
||||
}
|
||||
}
|
||||
if (offset + sizeof(struct gfs2_quota) > PAGE_CACHE_SIZE)
|
||||
nbytes = PAGE_CACHE_SIZE - offset;
|
||||
memcpy(kaddr + offset, ptr, nbytes);
|
||||
flush_dcache_page(page);
|
||||
kunmap_atomic(kaddr, KM_USER0);
|
||||
unlock_page(page);
|
||||
page_cache_release(page);
|
||||
|
||||
/* If quota straddles page boundary, we need to update the rest of the
|
||||
* quota at the beginning of the next page */
|
||||
if (offset != 0) { /* first page, offset is closer to PAGE_CACHE_SIZE */
|
||||
ptr = ptr + nbytes;
|
||||
nbytes = sizeof(struct gfs2_quota) - nbytes;
|
||||
offset = 0;
|
||||
index++;
|
||||
goto get_a_page;
|
||||
}
|
||||
|
||||
/* Update the disk inode timestamp and size (if extended) */
|
||||
err = gfs2_meta_inode_buffer(ip, &dibh);
|
||||
if (err)
|
||||
goto unlock;
|
||||
goto out;
|
||||
|
||||
size = loc + sizeof(struct gfs2_quota);
|
||||
if (size > inode->i_size) {
|
||||
|
|
@ -715,7 +747,9 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
|
|||
brelse(dibh);
|
||||
mark_inode_dirty(inode);
|
||||
|
||||
unlock:
|
||||
out:
|
||||
return err;
|
||||
unlock_out:
|
||||
unlock_page(page);
|
||||
page_cache_release(page);
|
||||
return err;
|
||||
|
|
@ -779,8 +813,10 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
|
|||
* rgrp since it won't be allocated during the transaction
|
||||
*/
|
||||
al->al_requested = 1;
|
||||
/* +1 in the end for block requested above for unstuffing */
|
||||
blocks = num_qd * data_blocks + RES_DINODE + num_qd + 1;
|
||||
/* +3 in the end for unstuffing block, inode size update block
|
||||
* and another block in case quota straddles page boundary and
|
||||
* two blocks need to be updated instead of 1 */
|
||||
blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;
|
||||
|
||||
if (nalloc)
|
||||
al->al_requested += nalloc * (data_blocks + ind_blocks);
|
||||
|
|
@ -1418,10 +1454,18 @@ static int gfs2_quota_get_xstate(struct super_block *sb,
|
|||
|
||||
memset(fqs, 0, sizeof(struct fs_quota_stat));
|
||||
fqs->qs_version = FS_QSTAT_VERSION;
|
||||
if (sdp->sd_args.ar_quota == GFS2_QUOTA_ON)
|
||||
fqs->qs_flags = (XFS_QUOTA_UDQ_ENFD | XFS_QUOTA_GDQ_ENFD);
|
||||
else if (sdp->sd_args.ar_quota == GFS2_QUOTA_ACCOUNT)
|
||||
fqs->qs_flags = (XFS_QUOTA_UDQ_ACCT | XFS_QUOTA_GDQ_ACCT);
|
||||
|
||||
switch (sdp->sd_args.ar_quota) {
|
||||
case GFS2_QUOTA_ON:
|
||||
fqs->qs_flags |= (XFS_QUOTA_UDQ_ENFD | XFS_QUOTA_GDQ_ENFD);
|
||||
/*FALLTHRU*/
|
||||
case GFS2_QUOTA_ACCOUNT:
|
||||
fqs->qs_flags |= (XFS_QUOTA_UDQ_ACCT | XFS_QUOTA_GDQ_ACCT);
|
||||
break;
|
||||
case GFS2_QUOTA_OFF:
|
||||
break;
|
||||
}
|
||||
|
||||
if (sdp->sd_quota_inode) {
|
||||
fqs->qs_uquota.qfs_ino = GFS2_I(sdp->sd_quota_inode)->i_no_addr;
|
||||
fqs->qs_uquota.qfs_nblks = sdp->sd_quota_inode->i_blocks;
|
||||
|
|
|
|||
|
|
@ -948,13 +948,13 @@ static int try_rgrp_fit(struct gfs2_rgrpd *rgd, struct gfs2_alloc *al)
|
|||
* try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
|
||||
* @rgd: The rgrp
|
||||
*
|
||||
* Returns: The inode, if one has been found
|
||||
* Returns: 0 if no error
|
||||
* The inode, if one has been found, in inode.
|
||||
*/
|
||||
|
||||
static struct inode *try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked,
|
||||
u64 skip)
|
||||
static u64 try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked,
|
||||
u64 skip)
|
||||
{
|
||||
struct inode *inode;
|
||||
u32 goal = 0, block;
|
||||
u64 no_addr;
|
||||
struct gfs2_sbd *sdp = rgd->rd_sbd;
|
||||
|
|
@ -979,14 +979,11 @@ static struct inode *try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked,
|
|||
if (no_addr == skip)
|
||||
continue;
|
||||
*last_unlinked = no_addr;
|
||||
inode = gfs2_inode_lookup(rgd->rd_sbd->sd_vfs, DT_UNKNOWN,
|
||||
no_addr, -1, 1);
|
||||
if (!IS_ERR(inode))
|
||||
return inode;
|
||||
return no_addr;
|
||||
}
|
||||
|
||||
rgd->rd_flags &= ~GFS2_RDF_CHECK;
|
||||
return NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1067,11 +1064,12 @@ static void forward_rgrp_set(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd)
|
|||
* Try to acquire rgrp in way which avoids contending with others.
|
||||
*
|
||||
* Returns: errno
|
||||
* unlinked: the block address of an unlinked block to be reclaimed
|
||||
*/
|
||||
|
||||
static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
|
||||
static int get_local_rgrp(struct gfs2_inode *ip, u64 *unlinked,
|
||||
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;
|
||||
|
|
@ -1080,6 +1078,7 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
|
|||
int loops = 0;
|
||||
int error, rg_locked;
|
||||
|
||||
*unlinked = 0;
|
||||
rgd = gfs2_blk2rgrpd(sdp, ip->i_goal);
|
||||
|
||||
while (rgd) {
|
||||
|
|
@ -1096,19 +1095,24 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
|
|||
case 0:
|
||||
if (try_rgrp_fit(rgd, al))
|
||||
goto out;
|
||||
if (rgd->rd_flags & GFS2_RDF_CHECK)
|
||||
inode = try_rgrp_unlink(rgd, last_unlinked, ip->i_no_addr);
|
||||
/* If the rg came in already locked, there's no
|
||||
way we can recover from a failed try_rgrp_unlink
|
||||
because that would require an iput which can only
|
||||
happen after the rgrp is unlocked. */
|
||||
if (!rg_locked && rgd->rd_flags & GFS2_RDF_CHECK)
|
||||
*unlinked = try_rgrp_unlink(rgd, last_unlinked,
|
||||
ip->i_no_addr);
|
||||
if (!rg_locked)
|
||||
gfs2_glock_dq_uninit(&al->al_rgd_gh);
|
||||
if (inode)
|
||||
return inode;
|
||||
if (*unlinked)
|
||||
return -EAGAIN;
|
||||
/* fall through */
|
||||
case GLR_TRYFAILED:
|
||||
rgd = recent_rgrp_next(rgd);
|
||||
break;
|
||||
|
||||
default:
|
||||
return ERR_PTR(error);
|
||||
return error;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1130,12 +1134,13 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
|
|||
case 0:
|
||||
if (try_rgrp_fit(rgd, al))
|
||||
goto out;
|
||||
if (rgd->rd_flags & GFS2_RDF_CHECK)
|
||||
inode = try_rgrp_unlink(rgd, last_unlinked, ip->i_no_addr);
|
||||
if (!rg_locked && rgd->rd_flags & GFS2_RDF_CHECK)
|
||||
*unlinked = try_rgrp_unlink(rgd, last_unlinked,
|
||||
ip->i_no_addr);
|
||||
if (!rg_locked)
|
||||
gfs2_glock_dq_uninit(&al->al_rgd_gh);
|
||||
if (inode)
|
||||
return inode;
|
||||
if (*unlinked)
|
||||
return -EAGAIN;
|
||||
break;
|
||||
|
||||
case GLR_TRYFAILED:
|
||||
|
|
@ -1143,7 +1148,7 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
|
|||
break;
|
||||
|
||||
default:
|
||||
return ERR_PTR(error);
|
||||
return error;
|
||||
}
|
||||
|
||||
rgd = gfs2_rgrpd_get_next(rgd);
|
||||
|
|
@ -1152,7 +1157,7 @@ static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
|
|||
|
||||
if (rgd == begin) {
|
||||
if (++loops >= 3)
|
||||
return ERR_PTR(-ENOSPC);
|
||||
return -ENOSPC;
|
||||
if (!skipped)
|
||||
loops++;
|
||||
flags = 0;
|
||||
|
|
@ -1172,7 +1177,7 @@ out:
|
|||
forward_rgrp_set(sdp, rgd);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1188,7 +1193,7 @@ int gfs2_inplace_reserve_i(struct gfs2_inode *ip, char *file, unsigned int line)
|
|||
struct gfs2_alloc *al = ip->i_alloc;
|
||||
struct inode *inode;
|
||||
int error = 0;
|
||||
u64 last_unlinked = NO_BLOCK;
|
||||
u64 last_unlinked = NO_BLOCK, unlinked;
|
||||
|
||||
if (gfs2_assert_warn(sdp, al->al_requested))
|
||||
return -EINVAL;
|
||||
|
|
@ -1204,14 +1209,19 @@ try_again:
|
|||
if (error)
|
||||
return error;
|
||||
|
||||
inode = get_local_rgrp(ip, &last_unlinked);
|
||||
if (inode) {
|
||||
error = get_local_rgrp(ip, &unlinked, &last_unlinked);
|
||||
if (error) {
|
||||
if (ip != GFS2_I(sdp->sd_rindex))
|
||||
gfs2_glock_dq_uninit(&al->al_ri_gh);
|
||||
if (IS_ERR(inode))
|
||||
return PTR_ERR(inode);
|
||||
iput(inode);
|
||||
if (error != -EAGAIN)
|
||||
return error;
|
||||
error = gfs2_unlinked_inode_lookup(ip->i_inode.i_sb,
|
||||
unlinked, &inode);
|
||||
if (inode)
|
||||
iput(inode);
|
||||
gfs2_log_flush(sdp, NULL);
|
||||
if (error == GLR_TRYFAILED)
|
||||
error = 0;
|
||||
goto try_again;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1113,7 +1113,7 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
|
|||
int error;
|
||||
|
||||
spin_lock(>->gt_spin);
|
||||
args.ar_commit = gt->gt_log_flush_secs;
|
||||
args.ar_commit = gt->gt_logd_secs;
|
||||
args.ar_quota_quantum = gt->gt_quota_quantum;
|
||||
if (gt->gt_statfs_slow)
|
||||
args.ar_statfs_quantum = 0;
|
||||
|
|
@ -1160,7 +1160,7 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
|
|||
else
|
||||
clear_bit(SDF_NOBARRIERS, &sdp->sd_flags);
|
||||
spin_lock(>->gt_spin);
|
||||
gt->gt_log_flush_secs = args.ar_commit;
|
||||
gt->gt_logd_secs = args.ar_commit;
|
||||
gt->gt_quota_quantum = args.ar_quota_quantum;
|
||||
if (args.ar_statfs_quantum) {
|
||||
gt->gt_statfs_slow = 0;
|
||||
|
|
@ -1305,8 +1305,8 @@ static int gfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
|
|||
}
|
||||
if (args->ar_discard)
|
||||
seq_printf(s, ",discard");
|
||||
val = sdp->sd_tune.gt_log_flush_secs;
|
||||
if (val != 60)
|
||||
val = sdp->sd_tune.gt_logd_secs;
|
||||
if (val != 30)
|
||||
seq_printf(s, ",commit=%d", val);
|
||||
val = sdp->sd_tune.gt_statfs_quantum;
|
||||
if (val != 30)
|
||||
|
|
@ -1334,7 +1334,8 @@ static int gfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
|
|||
}
|
||||
if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags))
|
||||
seq_printf(s, ",nobarrier");
|
||||
|
||||
if (test_bit(SDF_DEMOTE, &sdp->sd_flags))
|
||||
seq_printf(s, ",demote_interface_used");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -232,6 +232,8 @@ static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len
|
|||
glops = gfs2_glops_list[gltype];
|
||||
if (glops == NULL)
|
||||
return -EINVAL;
|
||||
if (!test_and_set_bit(SDF_DEMOTE, &sdp->sd_flags))
|
||||
fs_info(sdp, "demote interface used\n");
|
||||
rv = gfs2_glock_get(sdp, glnum, glops, 0, &gl);
|
||||
if (rv)
|
||||
return rv;
|
||||
|
|
@ -468,8 +470,6 @@ static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\
|
|||
} \
|
||||
TUNE_ATTR_2(name, name##_store)
|
||||
|
||||
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(max_readahead, 0);
|
||||
|
|
@ -481,8 +481,6 @@ TUNE_ATTR(statfs_quantum, 1);
|
|||
TUNE_ATTR_3(quota_scale, quota_scale_show, quota_scale_store);
|
||||
|
||||
static struct attribute *tune_attrs[] = {
|
||||
&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_max_readahead.attr,
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@
|
|||
#include "meta_io.h"
|
||||
#include "trans.h"
|
||||
#include "util.h"
|
||||
#include "trace_gfs2.h"
|
||||
|
||||
int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
|
||||
unsigned int revokes)
|
||||
|
|
@ -75,6 +76,23 @@ 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);
|
||||
trace_gfs2_log_blocks(sdp, blks);
|
||||
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;
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче