[Ocfs2-commits] branch, master, updated. 21b8b1ccc3e9f592d6d377d4856aff49834c9a25

svn-commits at oss.oracle.com svn-commits at oss.oracle.com
Thu May 27 05:15:22 PDT 2010


This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "The ocfs2 filesystem version 1.8".

The branch, master has been updated
       via  21b8b1ccc3e9f592d6d377d4856aff49834c9a25 (commit)
       via  1932fca067c587c42beb28727c292be8835709ea (commit)
       via  917df45e8efaa7a5735e83407b0bf0a092b7c5d5 (commit)
       via  b4b1bc8b979ab4deae7348a934ce20155d154439 (commit)
       via  e0e80ac0f73a8eccdc18a477b1256cd79647ca52 (commit)
       via  198e1e13a16d886fe44deb358f9713fc6d1e1929 (commit)
       via  0d8cb4276ecceabc35f4c41415ddf09e2ed093d8 (commit)
       via  3584e8b1f8aa0c297c0bda3afc0f381503415512 (commit)
       via  8a0b89801584350ef30a1dcc1c46b9a8be0f4083 (commit)
       via  7a198393f7c0583c88b8f739a954ea3235dc9458 (commit)
       via  c67b59d160f6687a10b4a31c9a58f1063be7203f (commit)
       via  37c224a5c5801cb4d4ccb27c31fb3577e931d332 (commit)
       via  d6e15f7f12bbf9f255f6020e4885e8c841ad25a0 (commit)
       via  e23ea106a8a238eee89702647460d02a34584169 (commit)
       via  372ddc6a4fcf8fe84a172333e91fc281428fa3a8 (commit)
       via  55bc3c2dd13467906e5b0fd38f00bf683620bc68 (commit)
       via  4289dd361add6c5796b8594286a4e2612ca6d839 (commit)
       via  aca2998a9e6c9c8993a02141b7c5aa18d0436683 (commit)
       via  f3be433b793d692dcd194e9bef45eb990d6474df (commit)
       via  9a46f92f31117ccd53c9558e64fc62c4913918b2 (commit)
       via  6a1a53820774189cb8d785e05945104d91b2219e (commit)
       via  0b0d3265d4c03a00c2c9e334992a5fa4ec0f549f (commit)
       via  77831f50a7fd7f3322b240add78f2a7dd54d1c98 (commit)
       via  3c517f300703118dcc93e9c39c61b2eba481c39c (commit)
       via  e3c8b411f77cc49d2e8015150ee527c5d53726ab (commit)
       via  f28e479d7792ed5faef906c26c4936f5cd5df804 (commit)
       via  384c78f272382ed4f79069bd1f64d9c985a23ae9 (commit)
       via  d8a774f04f9f6e9dfc97aef4ec83c58ad5e8a5f4 (commit)
       via  413241afe563b769de5de5976d08351c1cc64f99 (commit)
       via  f61c0787954f9f52a670b3ade6f2e73d2c7c05df (commit)
       via  324afb87c8546ade595290e43e82becbaadcbe3a (commit)
       via  83ac21f02063804985f3c81f583fb899f2543455 (commit)
       via  e92996ec2c84954879db9e5f7bb5cdc09d3b2a7d (commit)
       via  8f73255baf65f6b95d8f77d63c161f6be97fb3fe (commit)
       via  bfb072f48af237e2d311b8a987293cf7b9d849fb (commit)
       via  7d63d40ab1391e09a97b1ae574f6097e86e37324 (commit)
       via  19e3773cb40eae7dd250d6b4e4b10c1ead5c8e6d (commit)
       via  11b6e02d928e14cb6780d204db4c128cca07c19d (commit)
       via  db3dc08afd40bd753ce2ac32cfea881e3ab7e35d (commit)
       via  a5d4d41e670885b2fb883affdb10119a07fff035 (commit)
       via  726dce29fddb0f3db85f55af6ff57b4d49e4d0e8 (commit)
       via  3472a36100d48b43567b82c4b0ca469b9203b8d4 (commit)
       via  4b457cc8ebed8677cb07732365873d5b7ccaf130 (commit)
       via  b2b5d6bb8e43d4b40301d7887fa8ae4b2500723c (commit)
       via  103a71b6e46528326c603be8cdd2b1f13277c62f (commit)
       via  788c0675bc48bcdf02417279b9b6b82e8336b467 (commit)
       via  e39f4e8413d69b70c82562d9f59d19734a467e5c (commit)
      from  441ae21dc39a0c3d8649753ad75cfd12c66945cb (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 21b8b1ccc3e9f592d6d377d4856aff49834c9a25
Author: Joel Becker <joel.becker at oracle.com>
Date:   Tue May 18 16:47:55 2010 -0700

    ocfs2: Silence a gcc warning.
    
    Mainline commit 18d3a98f3c1b0e27ce026afa4d1ef042f2903726
    
    ocfs2_block_group_claim_bits() is never called with min_bits=0, but we
    shouldn't leave status undefined if it ever is.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 1932fca067c587c42beb28727c292be8835709ea
Author: Tao Ma <tao.ma at oracle.com>
Date:   Thu May 13 22:49:05 2010 +0800

    ocfs2: Don't retry xattr set in case value extension fails.
    
    Mainline commit 5f5261acb059f43c7fb9a2fac9d32c6ef4df2ed5
    
    In normal xattr set, the set sequence is inode, xattr block
    and finally xattr bucket if we meet with a ENOSPC. But there
    is a corner case.
    So consider we will set a xattr whose value will be stored in
    a cluster, and there is no xattr block by now. So we will
    reserve 1 xattr block and 1 cluster for setting it. Now if we
    fail in value extension(in case the volume is almost full and
    we can't allocate the cluster because the check in
    ocfs2_test_bg_bit_allocatable), ENOSPC will be returned. So
    we will try to create a bucket(this time there is a chance that
    the reserved cluster will be used), and when we try value extension
    again, kernel bug happens. We did meet with it. Check the bug below.
    http://oss.oracle.com/bugzilla/show_bug.cgi?id=1251
    
    This patch just try to avoid this by adding a set_abort in
    ocfs2_xattr_set_ctxt, so in case ENOSPC happens in value extension,
    we will check whether it is caused by the real ENOSPC or just the
    full of inode or xattr block. If it is the first case, we set set_abort
    so that we don't try any further. we are safe to exit directly here
    ince it is really ENOSPC.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 917df45e8efaa7a5735e83407b0bf0a092b7c5d5
Author: Wengang Wang <wen.gang.wang at oracle.com>
Date:   Mon May 17 20:20:44 2010 +0800

    ocfs2:dlm: avoid dlm->ast_lock lockres->spinlock dependency break
    
    Mainline commit d9ef75221a6247b758e1d7e18edb661996e4b7cf
    
    Currently we process a dirty lockres with the lockres->spinlock taken. While
    during the process, we may need to lock on dlm->ast_lock. This breaks the
    dependency of dlm->ast_lock(lock first) and lockres->spinlock(lock second).
    
    This patch fixes the problem.
    Since we can't release lockres->spinlock, we have to take dlm->ast_lock
    just before taking the lockres->spinlock and release it after lockres->spinlock
    is released. And use __dlm_queue_bast()/__dlm_queue_ast(), the nolock version,
    in dlm_shuffle_lists(). There are no too many locks on a lockres, so there is no
    performance harm.
    
    Signed-off-by: Wengang Wang <wen.gang.wang at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit b4b1bc8b979ab4deae7348a934ce20155d154439
Author: Tao Ma <tao.ma at oracle.com>
Date:   Mon May 10 18:09:47 2010 +0800

    ocfs2: Reset xattr value size after xa_cleanup_value_truncate().
    
    Mainline commit d5a7df0649fa6a1e7800785d760e2c7d7a3204de
    
    In ocfs2_prepare_xattr_entry, if we fail to grow an existing value,
    xa_cleanup_value_truncate() will leave the old entry in place.  Thus, we
    reset its value size.  However, if we were allocating a new value, we
    must not reset the value size or we will BUG().  This resolves
    oss.oracle.com bug 1247.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit e0e80ac0f73a8eccdc18a477b1256cd79647ca52
Author: Julia Lawall <julia at diku.dk>
Date:   Fri May 14 21:30:48 2010 +0200

    fs/ocfs2/dlm: Use kstrdup
    
    Mainline commit 316ce2ba8e74a7bb9153b9f93adc883cb1ceb9fd
    
    Use kstrdup when the goal of an allocation is copy a string into the
    allocated region.
    
    The semantic patch that makes this change is as follows:
    (http://coccinelle.lip6.fr/)
    
    // <smpl>
    @@
    expression from,to;
    expression flag,E1,E2;
    statement S;
    @@
    
    -  to = kmalloc(strlen(from) + 1,flag);
    +  to = kstrdup(from, flag);
       ... when != \(from = E1 \| to = E1 \)
       if (to==NULL || ...) S
       ... when != \(from = E2 \| to = E2 \)
    -  strcpy(to, from);
    // </smpl>
    
    Signed-off-by: Julia Lawall <julia at diku.dk>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 198e1e13a16d886fe44deb358f9713fc6d1e1929
Author: Julia Lawall <julia at diku.dk>
Date:   Tue May 11 20:28:14 2010 +0200

    fs/ocfs2/dlm: Drop memory allocation cast
    
    Mainline commit 3914ed0cec6532ab4feb202424fc95ad05024497
    
    Drop cast on the result of kmalloc and similar functions.
    
    The semantic patch that makes this change is as follows:
    (http://coccinelle.lip6.fr/)
    
    // <smpl>
    @@
    type T;
    @@
    
    - (T *)
      (\(kmalloc\|kzalloc\|kcalloc\|kmem_cache_alloc\|kmem_cache_zalloc\|
       kmem_cache_alloc_node\|kmalloc_node\|kzalloc_node\)(...))
    // </smpl>
    
    Signed-off-by: Julia Lawall <julia at diku.dk>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 0d8cb4276ecceabc35f4c41415ddf09e2ed093d8
Author: Tristan Ye <tristan.ye at oracle.com>
Date:   Tue May 11 17:54:45 2010 +0800

    Ocfs2: Optimize punching-hole code.
    
    Mainline commit c1631d4a484fbb498e35d661f1aebd64c86b66bf
    
    This patch simplifies the logic of handling existing holes and
    skipping extent blocks and removes some confusing comments.
    
    The patch survived the fill_verify_holes testcase in ocfs2-test.
    It also passed my manual sanity check and stress tests with enormous
    extent records.
    
    Currently punching a hole on a file with 3+ extent tree depth was
    really a performance disaster.  It can even take several hours,
    though we may not hit this in real life with such a huge extent
    number.
    
    One simple way to improve the performance is quite straightforward.
    From the logic of truncate, we can punch the hole from hole_end to
    hole_start, which reduces the overhead of btree operations in a
    significant way, such as tree rotation and moving.
    
    Following is the testing result when punching hole from 0 to file end
    in bytes, on a 1G file, 1G file consists of 256k extent records, each record
    cover 4k data(just one cluster, clustersize is 4k):
    
    ===========================================================================
     * Original punching-hole mechanism:
    ===========================================================================
    
       I waited 1 hour for its completion, unfortunately it's still ongoing.
    
    ===========================================================================
     * Patched punching-hode mechanism:
    ===========================================================================
    
       real 0m2.518s
       user 0m0.000s
       sys  0m2.445s
    
    That means we've gained up to 1000 times improvement on performance in this
    case, whee! It's fairly cool. and it looks like that performance gain will
    be raising when extent records grow.
    
    The patch was based on my former 2 patches, which were about truncating
    codes optimization and fixup to handle CoW on punching hole.
    
    Signed-off-by: Tristan Ye <tristan.ye at oracle.com>
    Acked-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 3584e8b1f8aa0c297c0bda3afc0f381503415512
Author: Tristan Ye <tristan.ye at oracle.com>
Date:   Tue May 11 17:54:44 2010 +0800

    Ocfs2: Make ocfs2_find_cpos_for_left_leaf() public.
    
    Mainline commit ee149a7c6cbaee0e3a1a7d9e9f92711228ef5236
    
    The original idea to pull ocfs2_find_cpos_for_left_leaf() out of
    alloc.c is to benefit punching-holes optimization patch, it however,
    can also be referred by other funcs in the future who want to do the
    same job.
    
    Signed-off-by: Tristan Ye <tristan.ye at oracle.com>
    Acked-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 8a0b89801584350ef30a1dcc1c46b9a8be0f4083
Author: Tristan Ye <tristan.ye at oracle.com>
Date:   Tue May 11 17:54:43 2010 +0800

    Ocfs2: Fix hole punching to correctly do CoW during cluster zeroing.
    
    Mainline commit e8aec068ecb1957630816cfa2c150c6b3ddd1790
    
    Based on the previous patch of optimizing truncate, the bugfix for
    refcount trees when punching holes can be fairly easy
    and straightforward since most of work we should take into account for
    refcounting have been completed already in ocfs2_remove_btree_range().
    
    This patch performs CoW for refcounted extents when a hole being punched
    whose start or end offset were in the middle of a cluster, which means
    partial zeroing of the cluster will be performed soon.
    
    The patch has been tested fixing the following bug:
    
    http://oss.oracle.com/bugzilla/show_bug.cgi?id=1216
    
    Signed-off-by: Tristan Ye <tristan.ye at oracle.com>
    Acked-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 7a198393f7c0583c88b8f739a954ea3235dc9458
Author: Tristan Ye <tristan.ye at oracle.com>
Date:   Tue May 11 17:54:42 2010 +0800

    Ocfs2: Optimize ocfs2 truncate to use ocfs2_remove_btree_range() instead.
    
    Mainline commit 78f94673d7faf01677f374f4ebbf324ff1a0aa6e
    
    Truncate is just a special case of punching holes(from new i_size to
    end), we therefore could take advantage of the existing
    ocfs2_remove_btree_range() to reduce the comlexity and redundancy in
    alloc.c.  The goal here is to make truncate more generic and
    straightforward.
    
    Several functions only used by ocfs2_commit_truncate() will smiply be
    removed.
    
    ocfs2_remove_btree_range() was originally used by the hole punching
    code, which didn't take refcount trees into account (definitely a bug).
    We therefore need to change that func a bit to handle refcount trees.
    It must take the refcount lock, calculate and reserve blocks for
    refcount tree changes, and decrease refcounts at the end.  We replace
    ocfs2_lock_allocators() here by adding a new func
    ocfs2_reserve_blocks_for_rec_trunc() which accepts some extra blocks to
    reserve.  This will not hurt any other code using
    ocfs2_remove_btree_range() (such as dir truncate and hole punching).
    
    I merged the following steps into one patch since they may be
    logically doing one thing, though I know it looks a little bit fat
    to review.
    
    1). Remove redundant code used by ocfs2_commit_truncate(), since we're
        moving to ocfs2_remove_btree_range anyway.
    
    2). Add a new func ocfs2_reserve_blocks_for_rec_trunc() for purpose of
        accepting some extra blocks to reserve.
    
    3). Change ocfs2_prepare_refcount_change_for_del() a bit to fit our
        needs.  It's safe to do this since it's only being called by
        truncate.
    
    4). Change ocfs2_remove_btree_range() a bit to take refcount case into
        account.
    
    5). Finally, we change ocfs2_commit_truncate() to call
        ocfs2_remove_btree_range() in a proper way.
    
    The patch has been tested normally for sanity check, stress tests
    with heavier workload will be expected.
    
    Based on this patch, fixing the punching holes bug will be fairly easy.
    
    Signed-off-by: Tristan Ye <tristan.ye at oracle.com>
    Acked-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit c67b59d160f6687a10b4a31c9a58f1063be7203f
Author: Joel Becker <joel.becker at oracle.com>
Date:   Thu May 27 19:12:33 2010 +0800

    ocfs2: Block signals for mkdir/link/symlink/O_CREAT.
    
    Mainline commit 547ba7c8efe43c2cabb38782e23572a6179dd1c1
    
    Once file or link creation gets going, it can't be interrupted by a
    signal.  They're not idempotent.
    
    This blocks signals in ocfs2_mknod(), ocfs2_link(), and ocfs2_symlink()
    once we start actually changing things.  ocfs2_mknod() covers mknod(),
    creat(), mkdir(), and open(O_CREAT).
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 37c224a5c5801cb4d4ccb27c31fb3577e931d332
Author: Joel Becker <joel.becker at oracle.com>
Date:   Wed Sep 2 17:17:36 2009 -0700

    ocfs2: Wrap signal blocking in void functions.
    
    Mainline commit e4b963f10e9026c83419b5c25b93a0350413cf16
    
    ocfs2 sometimes needs to block signals around dlm operations, but it
    currently does it with sigprocmask().  Even worse, it's checking the
    error code of sigprocmask().  The in-kernel sigprocmask() can only error
    if you get the SIG_* argument wrong.  We don't.
    
    Wrap the sigprocmask() calls with ocfs2_[un]block_signals().  These
    functions are void, but they will BUG() if somehow sigprocmask() returns
    an error.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit d6e15f7f12bbf9f255f6020e4885e8c841ad25a0
Author: Tao Ma <tao.ma at oracle.com>
Date:   Thu Mar 18 15:54:22 2010 +0800

    ocfs2: enable discontig block group support.
    
    Mainline commit 1a934c3e57594588c373aea858e4593cdfcba4f4
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit e23ea106a8a238eee89702647460d02a34584169
Author: Tao Ma <tao.ma at oracle.com>
Date:   Tue Apr 27 08:30:36 2010 +0800

    ocfs2: Set ac_last_group properly with discontig group.
    
    Mainline commit abf1b3cb5b20fbad27ca9c7497235eeb4dd3f4fd
    
    ac_last_group is used to record the last block group we
    used during allocation. But the initialization process
    only calls ocfs2_which_suballoc_group and fails to
    use suballoc_loc properly. So let us do it.
    Another function ocfs2_test_suballoc_bit also needs fix.
    
    I have searched all the callers of ocfs2_which_suballoc_group,
    and all the callers notices suballoc_loc now.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit 372ddc6a4fcf8fe84a172333e91fc281428fa3a8
Author: Tao Ma <tao.ma at oracle.com>
Date:   Mon Mar 22 14:20:18 2010 +0800

    ocfs2: Free block to the right block group.
    
    Mainline commit 74380c479ad83addeff8a172ab95f59557b5b0c3
    
    In case the block we are going to free is allocated from
    a discontiguous block group, we have to use suballoc_loc
    to be the right group.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit 55bc3c2dd13467906e5b0fd38f00bf683620bc68
Author: Tao Ma <tao.ma at oracle.com>
Date:   Mon May 17 15:14:17 2010 +0800

    ocfs2: Add ocfs2_gd_is_discontig.
    
    Mainline commit af2bf0d86019e0b0306965321096f8380b7ca830
    
    Add ocfs2_gd_is_discontig so that we can test whether
    a group descriptor is discontiguous or not.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit 4289dd361add6c5796b8594286a4e2612ca6d839
Author: Tao Ma <tao.ma at oracle.com>
Date:   Tue Apr 13 14:38:06 2010 +0800

    ocfs2: ocfs2_group_bitmap_size has to handle old volume.
    
    Mainline commit 8571882c21e5073b2f96147ec4ff9b7042339e1b
    
    ocfs2_group_bitmap_size has to handle the case when the
    volume don't have discontiguous block group support. So
    pass the feature_incompat in and check it.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit aca2998a9e6c9c8993a02141b7c5aa18d0436683
Author: Tao Ma <tao.ma at oracle.com>
Date:   Thu Apr 22 14:09:15 2010 +0800

    ocfs2: Some tiny bug fixes for discontiguous block allocation.
    
    Mainline commit 4711954eaa8d30f653fda238cecf919f1ae40d6f
    
    The fixes include:
    1. some endian problems.
    2. we should use bit/bpc in ocfs2_block_group_grow_discontig to
       allocate clusters.
    3. set num_clusters properly in __ocfs2_claim_clusters.
    4. change name from ocfs2_supports_discontig_bh to
       ocfs2_supports_discontig_bg.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit f3be433b793d692dcd194e9bef45eb990d6474df
Author: Joel Becker <joel.becker at oracle.com>
Date:   Fri Mar 26 10:10:08 2010 +0800

    ocfs2: Don't relink cluster groups when allocating discontig block groups
    
    Mainline commit 95ec0adf0b56d6a3f0ca1ec87173311898486b2e
    
    We don't have enough credits, and the filesystem is in a full state
    anyway.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 9a46f92f31117ccd53c9558e64fc62c4913918b2
Author: Joel Becker <joel.becker at oracle.com>
Date:   Fri Mar 26 10:09:29 2010 +0800

    ocfs2: Grow discontig block groups in one transaction.
    
    Mainline commit 8b06bc592ebc5a31e8d0b9c2ab17c6e78dde1f86
    
    Rather than extending the transaction every time we add an extent to a
    discontiguous block group, we grab enough credits to fill the extent
    list up front.  This means we can free the bits in the same transaction
    if we end up not getting enough space.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 6a1a53820774189cb8d785e05945104d91b2219e
Author: Joel Becker <joel.becker at oracle.com>
Date:   Fri Mar 26 10:09:15 2010 +0800

    ocfs2: Set suballoc_loc on allocated metadata.
    
    Mainline commit 2b6cb576aa80611f1f6a3c88708d1e68a8d97985
    
    Get the suballoc_loc from ocfs2_claim_new_inode() or
    ocfs2_claim_metadata().  Store it on the appropriate field of the block
    we just allocated.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 0b0d3265d4c03a00c2c9e334992a5fa4ec0f549f
Author: Joel Becker <joel.becker at oracle.com>
Date:   Fri Mar 26 10:08:59 2010 +0800

    ocfs2: Return allocated metadata blknos on the ocfs2_suballoc_result.
    
    Mainline commit ba2066351b630f0205ebf725f5c81a2a07a77cd7
    
    Rather than calculating the resulting block number, return it on the
    ocfs2_suballoc_result structure.  This way we can calculate block
    numbers for discontiguous block groups.
    
    Cluster groups keep doing it the old way.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 77831f50a7fd7f3322b240add78f2a7dd54d1c98
Author: Joel Becker <joel.becker at oracle.com>
Date:   Thu May 6 13:59:06 2010 +0800

    ocfs2: ocfs2_claim_*() don't need an ocfs2_super argument.
    
    Mainline commit 1ed9b777f77929ae961d6f9cdf828a07200ba71c
    
    They all take an ocfs2_alloc_context, which has the allocation inode.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit 3c517f300703118dcc93e9c39c61b2eba481c39c
Author: Joel Becker <joel.becker at oracle.com>
Date:   Fri Mar 26 10:08:27 2010 +0800

    ocfs2: Trim suballocations if they cross discontiguous regions
    
    Mainline commit 13e434cf0cacd2f03a7f4cd077e3e995ef5ef710
    
    A discontiguous block group can find a range of free bits that straddle
    more than one region of its space.  Callers can't handle that, so we
    trim the returned bits until they fit within one region.
    
    Only cluster allocations ask for min_bits>1.  Discontiguous block groups
    are only for block allocations.  So min_bits doesn't matter here.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit e3c8b411f77cc49d2e8015150ee527c5d53726ab
Author: Joel Becker <joel.becker at oracle.com>
Date:   Fri Mar 26 10:08:07 2010 +0800

    ocfs2: ocfs2_claim_suballoc_bits() doesn't need an osb argument.
    
    Mainline commit aa8f8e93c898a0319bcd6c79a9a42fe52abac7d7
    
    It's contained on ac->ac_inode->i_sb anyway.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit f28e479d7792ed5faef906c26c4936f5cd5df804
Author: Joel Becker <joel.becker at oracle.com>
Date:   Fri Mar 26 10:07:42 2010 +0800

    ocfs2: Add suballoc_loc to metadata blocks.
    
    Mainline commit 9cbc01231e82f9390edaea2b766abcb7165dc4b2
    
    We need a suballoc_loc field on any suballocated block.  Define them.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 384c78f272382ed4f79069bd1f64d9c985a23ae9
Author: Joel Becker <joel.becker at oracle.com>
Date:   Tue Apr 13 14:30:19 2010 +0800

    ocfs2: Pass suballocation results back via a structure.
    
    Mainline commit 7d1fe093bf04124dcc50c5dde1765bd098464bfa
    
    We're going to be adding more info to a suballocator allocation.  Rather
    than growing every function in the chain, let's pass a result structure
    around.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit d8a774f04f9f6e9dfc97aef4ec83c58ad5e8a5f4
Author: Joel Becker <joel.becker at oracle.com>
Date:   Tue Apr 13 14:26:32 2010 +0800

    ocfs2: Allocate discontiguous block groups.
    
    Mainline commit 798db35f4649eac2778381c390ed7d12de9ec767
    
    If we cannot get a contiguous region for a block group, allocate a
    discontiguous one when the filesystem supports it.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit 413241afe563b769de5de5976d08351c1cc64f99
Author: Joel Becker <joel.becker at oracle.com>
Date:   Tue Apr 13 14:26:12 2010 +0800

    ocfs2: Define data structures for discontiguous block groups.
    
    Mainline commit 4cbe4249d6586d5d88ef271e07302407a14c8443
    
    Defines the OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG feature bit and modifies
    struct ocfs2_group_desc for the feature.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>
    Signed-off-by: Tao Ma <tao.ma at oracle.com>

commit f61c0787954f9f52a670b3ade6f2e73d2c7c05df
Author: Sunil Mushran <sunil.mushran at oracle.com>
Date:   Wed May 5 16:25:08 2010 -0700

    ocfs2/dlm: Increase o2dlm lockres hash size
    
    Mainline commit 0467ae954d1843de65e7cf8f706f88fe65cd8418
    
    Lockres hash size of 16KB is far too small for large filesystems (where we
    have hundreds of thousands of lock resources stored in the table).
    This patch increases it to 128KB.
    
    Signed-off-by: Sunil Mushran <sunil.mushran at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 324afb87c8546ade595290e43e82becbaadcbe3a
Author: Tao Ma <tao.ma at oracle.com>
Date:   Mon Apr 26 14:34:57 2010 +0800

    ocfs2: Make ocfs2_extend_trans() really extend.
    
    Mainline commit c901fb00731e307c2c6e8c7d5eee005df5835f9d
    
    In ocfs2, we use ocfs2_extend_trans() to extend a journal handle's
    blocks. But if jbd2_journal_extend() fails, it will only restart
    with the the new number of blocks.  This tends to be awkward since
    in most cases we want additional reserved blocks. It makes our code
    harder to mantain since the caller can't be sure all the original
    blocks will not be accessed and dirtied again.  There are 15 callers
    of ocfs2_extend_trans() in fs/ocfs2, and 12 of them have to add
    h_buffer_credits before they call ocfs2_extend_trans().  This makes
    ocfs2_extend_trans() really extend atop the original block count.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 83ac21f02063804985f3c81f583fb899f2543455
Author: Tao Ma <tao.ma at oracle.com>
Date:   Tue Apr 6 16:46:46 2010 +0800

    ocfs2/trivial: Code cleanup for allocation reservation.
    
    Mainline commit 3e4218df3176657be72ad2fa199779be6c11fe4f
    
    Two tiny cleanup for allocation reservation.
    1. Remove some extra codes in ocfs2_local_alloc_find_clear_bits.
    2. Remove an unuseful variables in ocfs2_find_resv_lhs.
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>
    Acked-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit e92996ec2c84954879db9e5f7bb5cdc09d3b2a7d
Author: Tao Ma <tao.ma at oracle.com>
Date:   Thu Apr 8 16:33:02 2010 +0800

    ocfs2: make ocfs2_adjust_resv_from_alloc simple.
    
    Mainline commit b065556a7d1a9205403db77a318a5c5aa530e701
    
    When we allocate some bits from the reservation, we always
    allocate from the r_start(see ocfs2_resmap_resv_bits).
    So there should be no reason to check between r_start
    and start. And I don't think we will change this behaviour
    later by allocating from some bits after r_start.  Why not make
    ocfs2_adjust_resv_from_alloc simple for now?
    
    The only chance we have to adjust the reservation is when we haven't
    reached the end. With this patch, the function is more readable.
    
    Note:
    btw, this patch also fixes an original bug in the function
    which I haven't found before.
    	if (end < ocfs2_resv_end(resv))
    		rhs = end - ocfs2_resv_end(resv);
    This code is of course buggy. ;)
    
    Signed-off-by: Tao Ma <tao.ma at oracle.com>
    Acked-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 8f73255baf65f6b95d8f77d63c161f6be97fb3fe
Author: Sunil Mushran <sunil.mushran at oracle.com>
Date:   Tue Apr 13 18:00:31 2010 -0700

    ocfs2: Make nointr a default mount option
    
    Mainline commit 4b37fcb7d41ce3b9264b9562d6ffd62db9294bd1
    
    OCFS2 has never really supported intr. This patch acknowledges this reality
    and makes nointr the default mount option. In a later patch, we intend to
    support intr.
    
    Signed-off-by: Sunil Mushran <sunil.mushran at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit bfb072f48af237e2d311b8a987293cf7b9d849fb
Author: Sunil Mushran <sunil.mushran at oracle.com>
Date:   Tue Apr 13 18:00:30 2010 -0700

    ocfs2/dlm: Make o2dlm domain join/leave messages KERN_NOTICE
    
    Mainline commit 5c80d4c9e5489d5930412add87501702fe5f93fb
    
    o2dlm join and leave messages are more than informational as they are
    required for debugging locking issues. This patch changes them from
    KERN_INFO to KERN_NOTICE.
    
    Signed-off-by: Sunil Mushran <sunil.mushran at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 7d63d40ab1391e09a97b1ae574f6097e86e37324
Author: Srinivas Eeda <srinivas.eeda at oracle.com>
Date:   Wed Mar 31 14:32:29 2010 -0700

    o2net: log socket state changes
    
    Mainline commit 23fd9abdc8f63c72fe3324e83d454ccecedaec37
    
    This patch logs socket state changes that lead to socket shutdown.
    
    Signed-off-by: Srinivas Eeda <srinivas.eeda at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 19e3773cb40eae7dd250d6b4e4b10c1ead5c8e6d
Author: Wengang Wang <wen.gang.wang at oracle.com>
Date:   Tue Mar 30 12:09:22 2010 +0800

    ocfs2: print node # when tcp fails
    
    Mainline commit a5196ec5ef80309fd390191c548ee1f2e8a327ee
    
    Print the node number of a peer node if sending it a message failed.
    
    Signed-off-by: Wengang Wang <wen.gang.wang at oracle.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 11b6e02d928e14cb6780d204db4c128cca07c19d
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Mon Apr 5 18:17:16 2010 -0700

    ocfs2: Add dir_resv_level mount option
    
    Mainline commit 83f92318fa33cc084e14e64dc903e605f75884c1
    
    The default behavior for directory reservations stays the same, but we add a
    mount option so people can tweak the size of directory reservations
    according to their workloads.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit db3dc08afd40bd753ce2ac32cfea881e3ab7e35d
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Mon Apr 5 18:17:15 2010 -0700

    ocfs2: change default reservation window sizes
    
    Mainline commit b07f8f24dfe54da0f074b78949044842e8df881f
    
    The default reservation size of 4 (32-bit windows) is a bit too ambitious.
    Scale it back to 16 bits (resv_level=2). I have been testing various sizes
    on a 4-node cluster which runs a mixed workload that is heavily threaded.
    With a 256MB local alloc, I get *roughly* the following levels of average file
    fragmentation:
    
    resv_level=0	70%
    resv_level=1	21%
    resv_level=2	23%
    resv_level=3	24%
    resv_level=4	60%
    resv_level=5	did not test
    resv_level=6	60%
    
    resv_level=2 seemed like a good compromise between not letting windows be
    too small, but not so big that heavier workloads will immediately suffer
    without tuning.
    
    This patch also change the behavior of directory reservations - they now
    track file reservations.  The previous compromise of giving directory
    windows only 8 bits wound up fragmenting more at some window sizes because
    file allocations had smaller unused windows to poach from.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit a5d4d41e670885b2fb883affdb10119a07fff035
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Mon Apr 5 18:17:14 2010 -0700

    ocfs2: increase the default size of local alloc windows
    
    Mainline commit 6b82021b9e91cd689fdffadbcdb9a42597bbe764
    
    I have observed that the current size of 8M gives us pretty poor
    fragmentation on multi-threaded workloads which do lots of writes.
    
    Generally, I can increase the size of local alloc windows and observe a
    marked decrease in fragmentation, even up and beyond window sizes of 512
    megabytes. This makes sense for a couple reasons - larger local alloc means
    more room for reservation windows. On multi-node workloads the larger local
    alloc helps as well because we don't have to do window slides as often.
    
    Also, I removed the OCFS2_DEFAULT_LOCAL_ALLOC_SIZE constant as it is no
    longer used and the comment above it was out of date.
    
    To test fragmentation, I used a workload which launched 4 threads that did
    4k writes into a series of about 140 alternating files.
    
    With resv_level=2, and a 4k/4k file system I observed the following average
    fragmentation for various localalloc= parameters:
    
    localalloc=	avg. fragmentation
    	8		48
    	32		16
    	64		10
    	120		7
    
    On larger cluster sizes, the difference is more dramatic.
    
    The new default size top out at 256M, which we'll only get for cluster
    sizes of 32K and above.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 726dce29fddb0f3db85f55af6ff57b4d49e4d0e8
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Mon Apr 5 18:17:13 2010 -0700

    ocfs2: clean up localalloc mount option size parsing
    
    Mainline commit 73c8a80003d13be54e2309865030404441075182
    
    This patch pulls the local alloc sizing code into localalloc.c and provides
    a callout to it from ocfs2_fill_super(). Behavior is essentially unchanged
    except that I correctly calculate the maximum local alloc size. The old code
    in ocfs2_parse_options() calculated the max size as:
    
    ocfs2_local_alloc_size(sb) * 8
    
    which is correct, in bits. Unfortunately though the option passed in is in
    megabytes. Ultimately, this bug made no real difference - the shrink code
    would catch a too-large size and bring it down to something reasonable.
    Still, it's less than efficient as-is.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

commit 3472a36100d48b43567b82c4b0ca469b9203b8d4
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Tue Mar 16 21:01:00 2010 -0700

    ocfs2: remove ocfs2_local_alloc_in_range()
    
    Mainline commit a57c8fd2ad238258cc983049008aea5f985804b2
    
    Inodes are always allocated from the global bitmap now so we don't need this
    any more. Also, the existing implementation bounces reservations around
    needlessly.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>

commit 4b457cc8ebed8677cb07732365873d5b7ccaf130
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Wed Feb 24 13:34:09 2010 -0800

    ocfs2: allocate btree internal block groups from the global bitmap
    
    Mainline commit 33d5d380d667ad264675cfdb297dfc3c5b6542cc
    
    Otherwise, the need for a very large contiguous allocation tends to
    wreak havoc on many inode allocation reservations on the local alloc, thus
    ruining any chances for contiguousness.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>

commit b2b5d6bb8e43d4b40301d7887fa8ae4b2500723c
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Mon Dec 7 13:16:07 2009 -0800

    ocfs2: use allocation reservations for directory data
    
    Mainline commit e3b4a97dbe9741a3227c3ed857a0632532fcd386
    
    Use the reservations system for unindexed dir tree allocations. We don't
    bother with the indexed tree as reads from it are mostly random anyway.
    Directory reservations are marked seperately, to allow the reservations code
    a chance to optimize their window sizes. This patch allocates only 8 bits
    for directory windows as they generally are not expected to grow as quickly
    as file data. Future improvements to dir window sizing can trivially be
    made.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>

commit 103a71b6e46528326c603be8cdd2b1f13277c62f
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Thu May 27 18:19:23 2010 +0800

    ocfs2: use allocation reservations during file write
    
    Mainline commit 4fe370afaae49c57619bb0bedb75de7e7c168308
    
    Add a per-inode reservations structure and pass it through to the
    reservations code.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>

commit 788c0675bc48bcdf02417279b9b6b82e8336b467
Author: Mark Fasheh <mfasheh at suse.com>
Date:   Thu May 27 17:04:39 2010 +0800

    ocfs2: allocation reservations
    
    Mainline commit d02f00cc057809d96c044cc72d5b9809d59f7d49
    
    This patch improves Ocfs2 allocation policy by allowing an inode to
    reserve a portion of the local alloc bitmap for itself. The reserved
    portion (allocation window) is advisory in that other allocation
    windows might steal it if the local alloc bitmap becomes
    full. Otherwise, the reservations are honored and guaranteed to be
    free. When the local alloc window is moved to a different portion of
    the bitmap, existing reservations are discarded.
    
    Reservation windows are represented internally by a red-black
    tree. Within that tree, each node represents the reservation window of
    one inode. An LRU of active reservations is also maintained. When new
    data is written, we allocate it from the inodes window. When all bits
    in a window are exhausted, we allocate a new one as close to the
    previous one as possible. Should we not find free space, an existing
    reservation is pulled off the LRU and cannibalized.
    
    Signed-off-by: Mark Fasheh <mfasheh at suse.com>

commit e39f4e8413d69b70c82562d9f59d19734a467e5c
Author: Joel Becker <joel.becker at oracle.com>
Date:   Thu May 27 17:27:22 2010 +0800

    ocfs2: Make ocfs2_journal_dirty() void.
    
    Mainline commit ec20cec7a351584ca6c70ead012e73d61f9a8e04
    
    jbd[2]_journal_dirty_metadata() only returns 0.  It's been returning 0
    since before the kernel moved to git.  There is no point in checking
    this error.
    
    ocfs2_journal_dirty() has been faithfully returning the status since the
    beginning.  All over ocfs2, we have blocks of code checking this can't
    fail status.  In the past few years, we've tried to avoid adding these
    checks, because they are pointless.  But anyone who looks at our code
    assumes they are needed.
    
    Finally, ocfs2_journal_dirty() is made a void function.  All error
    checking is removed from other files.  We'll BUG_ON() the status of
    jbd2_journal_dirty_metadata() just in case they change it someday.  They
    won't.
    
    Signed-off-by: Joel Becker <joel.becker at oracle.com>

-----------------------------------------------------------------------

Summary of changes:
 fs/ocfs2/Makefile          |    4 +-
 fs/ocfs2/alloc.c           |  908 +++++++++++---------------------------------
 fs/ocfs2/alloc.h           |   12 +-
 fs/ocfs2/aops.c            |    3 +
 fs/ocfs2/cluster/masklog.c |    1 +
 fs/ocfs2/cluster/masklog.h |    1 +
 fs/ocfs2/cluster/tcp.c     |    3 +
 fs/ocfs2/dir.c             |   75 ++---
 fs/ocfs2/dlm/dlmast.c      |    8 +-
 fs/ocfs2/dlm/dlmcommon.h   |    4 +-
 fs/ocfs2/dlm/dlmconvert.c  |    4 +-
 fs/ocfs2/dlm/dlmdomain.c   |   28 +-
 fs/ocfs2/dlm/dlmlock.c     |    6 +-
 fs/ocfs2/dlm/dlmmaster.c   |   30 +-
 fs/ocfs2/dlm/dlmrecovery.c |   27 +-
 fs/ocfs2/dlm/dlmthread.c   |   16 +-
 fs/ocfs2/dlm/dlmunlock.c   |    3 +-
 fs/ocfs2/file.c            |  215 +++++++++---
 fs/ocfs2/inode.c           |   44 +--
 fs/ocfs2/inode.h           |    2 +
 fs/ocfs2/journal.c         |   26 +-
 fs/ocfs2/journal.h         |   15 +-
 fs/ocfs2/localalloc.c      |  275 ++++++++++----
 fs/ocfs2/localalloc.h      |    3 +
 fs/ocfs2/mmap.c            |   48 +--
 fs/ocfs2/namei.c           |   91 ++---
 fs/ocfs2/ocfs2.h           |   22 +
 fs/ocfs2/ocfs2_fs.h        |  144 ++++++--
 fs/ocfs2/quota_global.c    |    4 +-
 fs/ocfs2/quota_local.c     |   50 +--
 fs/ocfs2/refcounttree.c    |   74 ++---
 fs/ocfs2/refcounttree.h    |    4 +-
 fs/ocfs2/reservations.c    |  847 +++++++++++++++++++++++++++++++++++++++++
 fs/ocfs2/reservations.h    |  159 ++++++++
 fs/ocfs2/resize.c          |   19 +-
 fs/ocfs2/suballoc.c        |  688 ++++++++++++++++++++++-----------
 fs/ocfs2/suballoc.h        |   21 +-
 fs/ocfs2/super.c           |   88 ++++-
 fs/ocfs2/super.h           |    7 +
 fs/ocfs2/xattr.c           |  103 ++---
 40 files changed, 2590 insertions(+), 1492 deletions(-)
 create mode 100644 fs/ocfs2/reservations.c
 create mode 100644 fs/ocfs2/reservations.h


hooks/post-receive
-- 
The ocfs2 filesystem version 1.8



More information about the Ocfs2-commits mailing list