1 files changed, 97 insertions, 6 deletions

diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index 72c198a004df..d2d278fb9819 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -46,6 +46,11 @@
 
 #include "buffer_head_io.h"
 
+#define NOT_ALLOC_NEW_GROUP             0
+#define ALLOC_NEW_GROUP                 1
+
+#define OCFS2_MAX_INODES_TO_STEAL       1024
+
 static inline void ocfs2_debug_bg(struct ocfs2_group_desc *bg);
 static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe);
 static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl);
@@ -106,7 +111,7 @@ static inline void ocfs2_block_to_cluster_group(struct inode *inode,
                                                 u64 *bg_blkno,
                                                 u16 *bg_bit_off);
 
-void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac)
+static void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
 {
         struct inode *inode = ac->ac_inode;
 
@@ -117,9 +122,17 @@ void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac)
                 mutex_unlock(&inode->i_mutex);
 
                 iput(inode);
+                ac->ac_inode = NULL;
         }
-        if (ac->ac_bh)
+        if (ac->ac_bh) {
                 brelse(ac->ac_bh);
+                ac->ac_bh = NULL;
+        }
+}
+
+void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac)
+{
+        ocfs2_free_ac_resource(ac);
         kfree(ac);
 }
 
@@ -391,7 +404,8 @@ bail:
 static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
                                        struct ocfs2_alloc_context *ac,
                                        int type,
-                                       u32 slot)
+                                       u32 slot,
+                                       int alloc_new_group)
 {
         int status;
         u32 bits_wanted = ac->ac_bits_wanted;
@@ -420,6 +434,7 @@ static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
         }
 
         ac->ac_inode = alloc_inode;
+        ac->ac_alloc_slot = slot;
 
         fe = (struct ocfs2_dinode *) bh->b_data;
         if (!OCFS2_IS_VALID_DINODE(fe)) {
@@ -446,6 +461,14 @@ static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
                         goto bail;
                 }
 
+                if (alloc_new_group != ALLOC_NEW_GROUP) {
+                        mlog(0, "Alloc File %u Full: wanted=%u, free_bits=%u, "
+                             "and we don't alloc a new group for it.\n",
+                             slot, bits_wanted, free_bits);
+                        status = -ENOSPC;
+                        goto bail;
+                }
+
                 status = ocfs2_block_group_alloc(osb, alloc_inode, bh);
                 if (status < 0) {
                         if (status != -ENOSPC)
@@ -490,7 +513,8 @@ int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
         (*ac)->ac_group_search = ocfs2_block_group_search;
 
         status = ocfs2_reserve_suballoc_bits(osb, (*ac),
-                                             EXTENT_ALLOC_SYSTEM_INODE, slot);
+                                             EXTENT_ALLOC_SYSTEM_INODE,
+                                             slot, ALLOC_NEW_GROUP);
         if (status < 0) {
                 if (status != -ENOSPC)
                         mlog_errno(status);
@@ -508,10 +532,42 @@ bail:
         return status;
 }
 
+static int ocfs2_steal_inode_from_other_nodes(struct ocfs2_super *osb,
+                                              struct ocfs2_alloc_context *ac)
+{
+        int i, status = -ENOSPC;
+        s16 slot = ocfs2_get_inode_steal_slot(osb);
+
+        /* Start to steal inodes from the first slot after ours. */
+        if (slot == OCFS2_INVALID_SLOT)
+                slot = osb->slot_num + 1;
+
+        for (i = 0; i < osb->max_slots; i++, slot++) {
+                if (slot == osb->max_slots)
+                        slot = 0;
+
+                if (slot == osb->slot_num)
+                        continue;
+
+                status = ocfs2_reserve_suballoc_bits(osb, ac,
+                                                     INODE_ALLOC_SYSTEM_INODE,
+                                                     slot, NOT_ALLOC_NEW_GROUP);
+                if (status >= 0) {
+                        ocfs2_set_inode_steal_slot(osb, slot);
+                        break;
+                }
+
+                ocfs2_free_ac_resource(ac);
+        }
+
+        return status;
+}
+
 int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
                             struct ocfs2_alloc_context **ac)
 {
         int status;
+        s16 slot = ocfs2_get_inode_steal_slot(osb);
 
         *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
         if (!(*ac)) {
@@ -525,9 +581,43 @@ int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
 
         (*ac)->ac_group_search = ocfs2_block_group_search;
 
+        /*
+         * slot is set when we successfully steal inode from other nodes.
+         * It is reset in 3 places:
+         * 1. when we flush the truncate log
+         * 2. when we complete local alloc recovery.
+         * 3. when we successfully allocate from our own slot.
+         * After it is set, we will go on stealing inodes until we find the
+         * need to check our slots to see whether there is some space for us.
+         */
+        if (slot != OCFS2_INVALID_SLOT &&
+            atomic_read(&osb->s_num_inodes_stolen) < OCFS2_MAX_INODES_TO_STEAL)
+                goto inode_steal;
+
+        atomic_set(&osb->s_num_inodes_stolen, 0);
         status = ocfs2_reserve_suballoc_bits(osb, *ac,
                                              INODE_ALLOC_SYSTEM_INODE,
-                                             osb->slot_num);
+                                             osb->slot_num, ALLOC_NEW_GROUP);
+        if (status >= 0) {
+                status = 0;
+
+                /*
+                 * Some inodes must be freed by us, so try to allocate
+                 * from our own next time.
+                 */
+                if (slot != OCFS2_INVALID_SLOT)
+                        ocfs2_init_inode_steal_slot(osb);
+                goto bail;
+        } else if (status < 0 && status != -ENOSPC) {
+                mlog_errno(status);
+                goto bail;
+        }
+
+        ocfs2_free_ac_resource(*ac);
+
+inode_steal:
+        status = ocfs2_steal_inode_from_other_nodes(osb, *ac);
+        atomic_inc(&osb->s_num_inodes_stolen);
         if (status < 0) {
                 if (status != -ENOSPC)
                         mlog_errno(status);
@@ -557,7 +647,8 @@ int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb,
 
         status = ocfs2_reserve_suballoc_bits(osb, ac,
                                              GLOBAL_BITMAP_SYSTEM_INODE,
-                                             OCFS2_INVALID_SLOT);
+                                             OCFS2_INVALID_SLOT,
+                                             ALLOC_NEW_GROUP);
         if (status < 0 && status != -ENOSPC) {
                 mlog_errno(status);
                 goto bail;