ocfs2: throttle back local alloc when low on disk space (9c7af40b) · Commits · 戴 / test

fs/ocfs2/localalloc.c

+186 −12

Original line number	Diff line number	Diff line
		@@ -73,16 +73,51 @@ static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
		static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
		struct inode *local_alloc_inode);

		static inline int ocfs2_la_state_enabled(struct ocfs2_super *osb)
		{
		return (osb->local_alloc_state == OCFS2_LA_THROTTLED \|\|
		osb->local_alloc_state == OCFS2_LA_ENABLED);
		}

		void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,
		unsigned int num_clusters)
		{
		spin_lock(&osb->osb_lock);
		if (osb->local_alloc_state == OCFS2_LA_DISABLED \|\|
		osb->local_alloc_state == OCFS2_LA_THROTTLED)
		if (num_clusters >= osb->local_alloc_default_bits) {
		cancel_delayed_work(&osb->la_enable_wq);
		osb->local_alloc_state = OCFS2_LA_ENABLED;
		}
		spin_unlock(&osb->osb_lock);
		}

		void ocfs2_la_enable_worker(struct work_struct *work)
		{
		struct ocfs2_super *osb =
		container_of(work, struct ocfs2_super,
		la_enable_wq.work);
		spin_lock(&osb->osb_lock);
		osb->local_alloc_state = OCFS2_LA_ENABLED;
		spin_unlock(&osb->osb_lock);
		}

		/*
		* Tell us whether a given allocation should use the local alloc
		* file. Otherwise, it has to go to the main bitmap.
		*
		* This function does semi-dirty reads of local alloc size and state!
		* This is ok however, as the values are re-checked once under mutex.
		*/
		int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits)
		{
		int la_bits = osb->local_alloc_bits;
		int ret = 0;
		int la_bits;

		spin_lock(&osb->osb_lock);
		la_bits = osb->local_alloc_bits;

		if (osb->local_alloc_state != OCFS2_LA_ENABLED)
		if (!ocfs2_la_state_enabled(osb))
		goto bail;

		/* la_bits should be at least twice the size (in clusters) of
		@@ -96,6 +131,7 @@ int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits)
		bail:
		mlog(0, "state=%d, bits=%llu, la_bits=%d, ret=%d\n",
		osb->local_alloc_state, (unsigned long long)bits, la_bits, ret);
		spin_unlock(&osb->osb_lock);
		return ret;
		}

		@@ -208,6 +244,9 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)

		mlog_entry_void();

		cancel_delayed_work(&osb->la_enable_wq);
		flush_workqueue(ocfs2_wq);

		if (osb->local_alloc_state == OCFS2_LA_UNUSED)
		goto out;

		@@ -445,7 +484,7 @@ out:
		}

		/*
		* make sure we've got at least bitswanted contiguous bits in the
		* make sure we've got at least bits_wanted contiguous bits in the
		* local alloc. You lose them when you drop i_mutex.
		*
		* We will add ourselves to the transaction passed in, but may start
		@@ -476,16 +515,18 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,

		mutex_lock(&local_alloc_inode->i_mutex);

		if (osb->local_alloc_state != OCFS2_LA_ENABLED) {
		status = -ENOSPC;
		goto bail;
		}

		if (bits_wanted > osb->local_alloc_bits) {
		mlog(0, "Asking for more than my max window size!\n");
		/*
		* We must double check state and allocator bits because
		* another process may have changed them while holding i_mutex.
		*/
		spin_lock(&osb->osb_lock);
		if (!ocfs2_la_state_enabled(osb) \|\|
		(bits_wanted > osb->local_alloc_bits)) {
		spin_unlock(&osb->osb_lock);
		status = -ENOSPC;
		goto bail;
		}
		spin_unlock(&osb->osb_lock);

		alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;

		@@ -513,6 +554,21 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
		mlog_errno(status);
		goto bail;
		}

		/*
		* Under certain conditions, the window slide code
		* might have reduced the number of bits available or
		* disabled the the local alloc entirely. Re-check
		* here and return -ENOSPC if necessary.
		*/
		status = -ENOSPC;
		if (!ocfs2_la_state_enabled(osb))
		goto bail;

		free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
		le32_to_cpu(alloc->id1.bitmap1.i_used);
		if (bits_wanted > free_bits)
		goto bail;
		}

		ac->ac_inode = local_alloc_inode;
		@@ -780,6 +836,85 @@ bail:
		return status;
		}

		enum ocfs2_la_event {
		OCFS2_LA_EVENT_SLIDE, /* Normal window slide. */
		OCFS2_LA_EVENT_FRAGMENTED, /* The global bitmap has
		* enough bits theoretically
		* free, but a contiguous
		* allocation could not be
		* found. */
		OCFS2_LA_EVENT_ENOSPC, /* Global bitmap doesn't have
		* enough bits free to satisfy
		* our request. */
		};
		#define OCFS2_LA_ENABLE_INTERVAL (30 * HZ)
		/*
		* Given an event, calculate the size of our next local alloc window.
		*
		* This should always be called under i_mutex of the local alloc inode
		* so that local alloc disabling doesn't race with processes trying to
		* use the allocator.
		*
		* Returns the state which the local alloc was left in. This value can
		* be ignored by some paths.
		*/
		static int ocfs2_recalc_la_window(struct ocfs2_super *osb,
		enum ocfs2_la_event event)
		{
		unsigned int bits;
		int state;

		spin_lock(&osb->osb_lock);
		if (osb->local_alloc_state == OCFS2_LA_DISABLED) {
		WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED);
		goto out_unlock;
		}

		/*
		* ENOSPC and fragmentation are treated similarly for now.
		*/
		if (event == OCFS2_LA_EVENT_ENOSPC \|\|
		event == OCFS2_LA_EVENT_FRAGMENTED) {
		/*
		* We ran out of contiguous space in the primary
		* bitmap. Drastically reduce the number of bits used
		* by local alloc until we have to disable it.
		*/
		bits = osb->local_alloc_bits >> 1;
		if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) {
		/*
		* By setting state to THROTTLED, we'll keep
		* the number of local alloc bits used down
		* until an event occurs which would give us
		* reason to assume the bitmap situation might
		* have changed.
		*/
		osb->local_alloc_state = OCFS2_LA_THROTTLED;
		osb->local_alloc_bits = bits;
		} else {
		osb->local_alloc_state = OCFS2_LA_DISABLED;
		}
		queue_delayed_work(ocfs2_wq, &osb->la_enable_wq,
		OCFS2_LA_ENABLE_INTERVAL);
		goto out_unlock;
		}

		/*
		* Don't increase the size of the local alloc window until we
		* know we might be able to fulfill the request. Otherwise, we
		* risk bouncing around the global bitmap during periods of
		* low space.
		*/
		if (osb->local_alloc_state != OCFS2_LA_THROTTLED)
		osb->local_alloc_bits = osb->local_alloc_default_bits;

		out_unlock:
		state = osb->local_alloc_state;
		spin_unlock(&osb->osb_lock);

		return state;
		}

		static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
		struct ocfs2_alloc_context **ac,
		struct inode **bitmap_inode,
		@@ -794,11 +929,20 @@ static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
		goto bail;
		}

		retry_enospc:
		(*ac)->ac_bits_wanted = osb->local_alloc_bits;

		status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
		if (status == -ENOSPC) {
		if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) ==
		OCFS2_LA_DISABLED)
		goto bail;

		ocfs2_free_ac_resource(*ac);
		memset(*ac, 0, sizeof(struct ocfs2_alloc_context));
		goto retry_enospc;
		}
		if (status < 0) {
		if (status != -ENOSPC)
		mlog_errno(status);
		goto bail;
		}
		@@ -852,6 +996,34 @@ static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
		* the more specific cluster api to claim bits. */
		status = ocfs2_claim_clusters(osb, handle, ac, osb->local_alloc_bits,
		&cluster_off, &cluster_count);
		if (status == -ENOSPC) {
		retry_enospc:
		/*
		* Note: We could also try syncing the journal here to
		* allow use of any free bits which the current
		* transaction can't give us access to. --Mark
		*/
		if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) ==
		OCFS2_LA_DISABLED)
		goto bail;

		status = ocfs2_claim_clusters(osb, handle, ac,
		osb->local_alloc_bits,
		&cluster_off,
		&cluster_count);
		if (status == -ENOSPC)
		goto retry_enospc;
		/*
		* We only shrunk the minimum number of in our
		* request - it's entirely possible that the allocator
		* might give us more than we asked for.
		*/
		if (status == 0) {
		spin_lock(&osb->osb_lock);
		osb->local_alloc_bits = cluster_count;
		spin_unlock(&osb->osb_lock);
		}
		}
		if (status < 0) {
		if (status != -ENOSPC)
		mlog_errno(status);
		@@ -895,6 +1067,8 @@ static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,

		mlog_entry_void();

		ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE);

		/* This will lock the main bitmap for us. */
		status = ocfs2_local_alloc_reserve_for_window(osb,
		&ac,

fs/ocfs2/localalloc.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -52,4 +52,8 @@ int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
		u32 *bit_off,
		u32 *num_bits);

		void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,
		unsigned int num_clusters);
		void ocfs2_la_enable_worker(struct work_struct *work);

		#endif /* OCFS2_LOCALALLOC_H */

fs/ocfs2/ocfs2.h

+19 −4

Original line number	Diff line number	Diff line
		@@ -171,9 +171,13 @@ struct ocfs2_alloc_stats

		enum ocfs2_local_alloc_state
		{
		OCFS2_LA_UNUSED = 0,
		OCFS2_LA_ENABLED,
		OCFS2_LA_DISABLED
		OCFS2_LA_UNUSED = 0, /* Local alloc will never be used for
		* this mountpoint. */
		OCFS2_LA_ENABLED, /* Local alloc is in use. */
		OCFS2_LA_THROTTLED, /* Local alloc is in use, but number
		* of bits has been reduced. */
		OCFS2_LA_DISABLED /* Local alloc has temporarily been
		* disabled. */
		};

		enum ocfs2_mount_options
		@@ -252,9 +256,20 @@ struct ocfs2_super
		struct ocfs2_journal *journal;
		unsigned long osb_commit_interval;

		struct delayed_work la_enable_wq;

		/*
		* Must hold local alloc i_mutex and osb->osb_lock to change
		* local_alloc_bits. Reads can be done under either lock.
		*/
		unsigned int local_alloc_bits;
		enum ocfs2_local_alloc_state local_alloc_state;
		unsigned int local_alloc_default_bits;

		enum ocfs2_local_alloc_state local_alloc_state; /* protected
		* by osb_lock */

		struct buffer_head *local_alloc_bh;

		u64 la_last_gd;

		/* Next two fields are for local node slot recovery during

fs/ocfs2/suballoc.c

+17 −14

Original line number	Diff line number	Diff line
		@@ -111,7 +111,7 @@ static inline void ocfs2_block_to_cluster_group(struct inode *inode,
		u64 *bg_blkno,
		u16 *bg_bit_off);

		static void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
		void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
		{
		struct inode *inode = ac->ac_inode;

		@@ -686,15 +686,6 @@ int ocfs2_reserve_clusters(struct ocfs2_super *osb,
		if ((status < 0) && (status != -ENOSPC)) {
		mlog_errno(status);
		goto bail;
		} else if (status == -ENOSPC) {
		/* reserve_local_bits will return enospc with
		* the local alloc inode still locked, so we
		* can change this safely here. */
		mlog(0, "Disabling local alloc\n");
		/* We set to OCFS2_LA_DISABLED so that umount
		* can clean up what's left of the local
		* allocation */
		osb->local_alloc_state = OCFS2_LA_DISABLED;
		}
		}

		@@ -1005,6 +996,7 @@ static int ocfs2_cluster_group_search(struct inode *inode,
		int search = -ENOSPC;
		int ret;
		struct ocfs2_group_desc gd = (struct ocfs2_group_desc ) group_bh->b_data;
		struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
		u16 tmp_off, tmp_found;
		unsigned int max_bits, gd_cluster_off;

		@@ -1045,6 +1037,12 @@ static int ocfs2_cluster_group_search(struct inode *inode,
		*bit_off = tmp_off;
		*bits_found = tmp_found;
		search = 0; /* success */
		} else if (tmp_found) {
		/*
		* Don't show bits which we'll be returning
		* for allocation to the local alloc bitmap.
		*/
		ocfs2_local_alloc_seen_free_bits(osb, tmp_found);
		}
		}

		@@ -1203,9 +1201,8 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
		status = -ENOSPC;
		/* for now, the chain search is a bit simplistic. We just use
		* the 1st group with any empty bits. */
		while ((status = ac->ac_group_search(alloc_inode, group_bh,
		bits_wanted, min_bits, bit_off,
		&tmp_bits)) == -ENOSPC) {
		while ((status = ac->ac_group_search(alloc_inode, group_bh, bits_wanted,
		min_bits, bit_off, &tmp_bits)) == -ENOSPC) {
		if (!bg->bg_next_group)
		break;

		@@ -1838,9 +1835,15 @@ int ocfs2_free_clusters(handle_t *handle,
		status = ocfs2_free_suballoc_bits(handle, bitmap_inode, bitmap_bh,
		bg_start_bit, bg_blkno,
		num_clusters);
		if (status < 0)
		if (status < 0) {
		mlog_errno(status);
		goto out;
		}

		ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb),
		num_clusters);

		out:
		mlog_exit(status);
		return status;
		}

fs/ocfs2/suballoc.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -147,6 +147,7 @@ static inline int ocfs2_is_cluster_bitmap(struct inode *inode)
		* apis above. */
		int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb,
		struct ocfs2_alloc_context *ac);
		void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac);

		/* given a cluster offset, calculate which block group it belongs to
		* and return that block offset. */

Admin message