ocfs2: Try to free truncate log when meeting ENOSPC in write.
PATCH 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288
The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
So this patch just try to resolve it. In case we see -ENOSPC in ocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.
--- fs/ocfs2/alloc.c | 3 ++ fs/ocfs2/aops.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++- fs/ocfs2/ocfs2.h | 2 + 3 files changed, 63 insertions(+), 1 deletions(-)
fs/ocfs2/alloc.c +3 -0
@@ -5858,6 +5858,7 @@ int ocfs2_truncate_log_append(struct ocfs2_super *osb,ocfs2_journal_dirty (handle, tl_bh); + osb->truncated_clusters += num_clusters; bail:mlog_exit (status);return status;
@@ -5929,6 +5930,8 @@ static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, i--; } + osb->truncated_clusters =0 ; + bail:mlog_exit (status);return status;
fs/ocfs2/aops.c +58 -1
96 lines not on this page · raw message
fs/ocfs2/ocfs2.h +2 -0
@@ -439,6 +439,8 @@ struct ocfs2_super/* rb tree root for refcount lock. */ struct rb_root osb_rf_lock_tree;struct ocfs2_refcount_tree *osb_ref_tree_lru; + +unsigned int truncated_clusters; };#define OCFS2_SB (sb) ((struct ocfs2_super *)(sb)->s_fs_info)
Signature · 1 line
1.7.1.571.gba4d01
PATCH 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Hi Tao,
Just some tiny comments;)
Quoted 49 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.Cc Mark Fasheh <[email protected]>Signed-off-by Tao Ma <[email protected]>--- fs/ocfs2/alloc.c | 3 ++ fs/ocfs2/aops.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++- fs/ocfs2/ocfs2.h | 2 + 3 files changed, 63 insertions(+), 1 deletions(-)fs/ocfs2/alloc.c +3
-0@@ -5858,6 +5858,7 @@ int ocfs2_truncate_log_append(struct ocfs2_super *osb,ocfs2_journal_dirty (handle, tl_bh); + osb->truncated_clusters += num_clusters; bail:mlog_exit (status);return status;@@ -5929,6 +5930,8 @@ static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, i--; } + osb->truncated_clusters =0 ; + bail:mlog_exit (status);return status;fs/ocfs2/aops.c +0
-0
fs/ocfs2/aops.c static int ocfs2_zero_tail(struct inode *inode, struct buffer_head *di_bh, · line 1651
Quoted 10 lines
fs/ocfs2/aops.c +7
-0@@ -1642,6 +1642,43 @@ static int ocfs2_zero_tail(struct inode *inode, struct buffer_head *di_bh,return ret; } +/* +* Try to flush truncate log if we can free enough clusters from it. +* As for return value, "< 0" means error, "0" no space and "1" means +* we have freed enough spaces and let the caller try to allocate again. +*/ +static int ocfs2_try_to_free_truncate_log (struct ocfs2_super *osb, +unsigned int needed)
why not use 'unsigned int *needed, and return the actual cluster being freed.
Quoted 69 lines
fs/ocfs2/aops.c +35
-1+{ +tid_t target; +int ret =0 ; +unsigned int truncated_clusters; + +mutex_lock (&osb->osb_tl_inode->i_mutex); + truncated_clusters = osb->truncated_clusters; +mutex_unlock (&osb->osb_tl_inode->i_mutex); + +/* +* Check whether we can succeed in allocating if we free +* the truncate log. +*/ +if (truncated_clusters < needed) + goto out; + + ret =ocfs2_flush_truncate_log (osb); +if (ret) { +mlog_errno (ret); + goto out; + } + +if (jbd2_journal_start_commit (osb->journal->j_journal, &target)) { +jbd2_log_wait_commit (osb->journal->j_journal, target); + ret =1 ; + } +out: +return ret; +} + int ocfs2_write_begin_nolock(struct file *filp, struct address_space *mapping, loff_t pos, unsigned len, unsigned flags,@@ -1649,7 +1686,7 @@ int ocfs2_write_begin_nolock(struct file *filp, struct buffer_head *di_bh, struct page *mmap_page) { int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS; -unsigned int clusters_to_alloc, extents_to_split; +unsigned int clusters_to_alloc, extents_to_split, clusters_need =0 ;struct ocfs2_write_ctxt *wc;struct inode *inode = mapping->host;struct ocfs2_super *osb =OCFS2_SB (inode->i_sb);@@ -1658,7 +1695,9 @@ int ocfs2_write_begin_nolock(struct file *filp,struct ocfs2_alloc_context *meta_ac =NULL ;handle_t *handle;struct ocfs2_extent_tree et; +int try_free =0 , ret1; +try_again: ret =ocfs2_alloc_write_ctxt (&wc, osb, pos, len, di_bh);if (ret) {mlog_errno (ret);@@ -1693,6 +1732,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; }else if (ret ==1 ) { + clusters_need = wc->w_clen; ret =ocfs2_refcount_cow (inode, filp, di_bh, wc->w_cpos, wc->w_clen,UINT_MAX );if (ret) {@@ -1707,6 +1747,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; } + clusters_need += clusters_to_alloc; di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
fs/ocfs2/aops.c out: · line 1874
Quoted 5 lines
fs/ocfs2/aops.c +2
-0@@ -1829,6 +1870,22 @@ out:ocfs2_free_alloc_context (data_ac);if (meta_ac)ocfs2_free_alloc_context (meta_ac); + +if (ret == -ENOSPC && !try_free) {
Literally, if (ret == -ENOSPC && try_free) make more sense here for a better readability;-)
You can set the try_free with a fixed value at the very beginning, which in other words, means set the
retry times we're allowing to perform after the allocation failure.
fs/ocfs2/aops.c out: · line 1879
Quoted 5 lines
fs/ocfs2/aops.c +5
-0+/* +* Try to free some truncate log so that we can have enough +* clusters to allocate. +*/ + try_free =1 ;
try_free--;
Quoted 25 lines
fs/ocfs2/aops.c +9
-0+ + ret1 =ocfs2_try_to_free_truncate_log (osb, clusters_need); +if (ret1 ==1 ) + goto try_again; + +if (ret1 <0 ) +mlog_errno (ret1); + } +return ret; }fs/ocfs2/ocfs2.h +2
-0@@ -439,6 +439,8 @@ struct ocfs2_super/* rb tree root for refcount lock. */ struct rb_root osb_rf_lock_tree;struct ocfs2_refcount_tree *osb_ref_tree_lru; + +unsigned int truncated_clusters; };#define OCFS2_SB (sb) ((struct ocfs2_super *)(sb)->s_fs_info)
PATCH 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Quoted 61 lines · tristan
Hi Tao,
Just some tiny comments;)
Quoted 56 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.Cc Mark Fasheh <[email protected]>Signed-off-by Tao Ma <[email protected]>---
fs/ocfs2/alloc.c| 3 ++fs/ocfs2/aops.c| 59
+++++++++++++++++++++++++++++++++++++++++++++++++++++-fs/ocfs2/ocfs2.h| 2 +3 files changed, 63 insertions(+), 1 deletions(-)fs/ocfs2/alloc.c +1
-0@@ -5858,6 +5858,7 @@ int ocfs2_truncate_log_append(struct ocfs2_super *osb,ocfs2_journal_dirty (handle, tl_bh); + osb->truncated_clusters += num_clusters;bail:
mlog_exit(status);
return status;fs/ocfs2/alloc.c +2
-0@@ -5929,6 +5930,8 @@ static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, i--; } + osb->truncated_clusters =0 ; +bail:
mlog_exit(status);
return status;fs/ocfs2/aops.c +0
-0@@ -1642,6 +1642,43 @@ static int ocfs2_zero_tail(struct inode *inode,struct buffer_head *di_bh, return ret; }
Quoted 9 lines
fs/ocfs2/aops.c static int ocfs2_zero_tail(struct inode *inode, struct buffer_head *di_bh, · line 1651
Quoted 7 lines
fs/ocfs2/aops.c +7
-0+/* +* Try to flush truncate log if we can free enough clusters from it. +* As for return value, "< 0" means error, "0" no space and "1" means +* we have freed enough spaces and let the caller try to allocate again. +*/ +static int ocfs2_try_to_free_truncate_log (struct ocfs2_super *osb, +unsigned int needed)why not use 'unsigned int *needed, and return the actual cluster being freed.
I don't think we need to return 'freed clusters' here(which indicates we will flush the truncate log no matter 'needed' is). what I want is that if we can free 'needed', just do it. If not, go 'exit' because even if we free some clusters, it can't fit our need and the allocation would still fail. 'Free some clusters' here means that we have to flush the truncate log and wait for the journal commit. It is a bit time-consuming, so why let the user wait for some time(for freeing some clusters in truncate log) while eventually he will get an ENOSPC?
Quoted 77 lines
Quoted 69 lines
fs/ocfs2/aops.c +30
-0+{ +tid_t target; +int ret =0 ; +unsigned int truncated_clusters; + +mutex_lock (&osb->osb_tl_inode->i_mutex); + truncated_clusters = osb->truncated_clusters; +mutex_unlock (&osb->osb_tl_inode->i_mutex); + +/* +* Check whether we can succeed in allocating if we free +* the truncate log. +*/ +if (truncated_clusters < needed) + goto out; + + ret =ocfs2_flush_truncate_log (osb); +if (ret) { +mlog_errno (ret); + goto out; + } + +if (jbd2_journal_start_commit (osb->journal->j_journal, &target)) { +jbd2_log_wait_commit (osb->journal->j_journal, target); + ret =1 ; + } +out: +return ret; +} + int ocfs2_write_begin_nolock(struct file *filp, struct address_space *mapping,
loff_tpos, unsigned len, unsigned flags,fs/ocfs2/aops.c +5
-1@@ -1649,7 +1686,7 @@ int ocfs2_write_begin_nolock(struct file *filp, struct buffer_head *di_bh, struct page *mmap_page) { int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS; -unsigned int clusters_to_alloc, extents_to_split; +unsigned int clusters_to_alloc, extents_to_split, clusters_need =0 ;struct ocfs2_write_ctxt *wc;struct inode *inode = mapping->host;struct ocfs2_super *osb =OCFS2_SB (inode->i_sb);@@ -1658,7 +1695,9 @@ int ocfs2_write_begin_nolock(struct file *filp,struct ocfs2_alloc_context *meta_ac =NULL ;handle_t *handle;struct ocfs2_extent_tree et; +int try_free =0 , ret1; +try_again: ret =ocfs2_alloc_write_ctxt (&wc, osb, pos, len, di_bh);if (ret) {mlog_errno (ret);@@ -1693,6 +1732,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; }else if (ret ==1 ) { + clusters_need = wc->w_clen; ret =ocfs2_refcount_cow (inode, filp, di_bh, wc->w_cpos, wc->w_clen,UINT_MAX );if (ret) {@@ -1707,6 +1747,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; } + clusters_need += clusters_to_alloc; di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;fs/ocfs2/aops.c out: · line 1874
Quoted 5 lines
fs/ocfs2/aops.c +2
-0@@ -1829,6 +1870,22 @@ out:ocfs2_free_alloc_context (data_ac);if (meta_ac)ocfs2_free_alloc_context (meta_ac); + +if (ret == -ENOSPC && !try_free) {Literally, if (ret ==
-ENOSPC&&try_free) make more sense here for a better readability;-)
Quoted 3 lines
You can set the
try_freewith a fixed value at the very beginning, which in other words, means set the
retry times we're allowing to perform after the allocation failure.
Is it really needed for the user to try several times? I am not sure. Yes, we can try several times, but if the first try doesn't work, do you think we can have another chance that some other process just happen to truncate and fill in the truncate log for us between 2 tries?
If yes, it is hard for us to tell how many times is appropriate to try. If the system is in this stage(nearly full and needs a truncate log flush to allocate clusters), I guess the right step is let the user know -ENOSPC does happen(if flush truncate log doesn't help either) and do something instead.
Regards,
Tao
PATCH 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Quoted 74 lines · Tao Ma
Quoted 61 lines · tristan
Hi Tao,
Just some tiny comments;)
Quoted 56 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.Cc Mark Fasheh <[email protected]>Signed-off-by Tao Ma <[email protected]>---
fs/ocfs2/alloc.c| 3 ++fs/ocfs2/aops.c| 59
+++++++++++++++++++++++++++++++++++++++++++++++++++++-fs/ocfs2/ocfs2.h| 2 +3 files changed, 63 insertions(+), 1 deletions(-)fs/ocfs2/alloc.c +1
-0@@ -5858,6 +5858,7 @@ int ocfs2_truncate_log_append(struct ocfs2_super *osb,ocfs2_journal_dirty (handle, tl_bh); + osb->truncated_clusters += num_clusters;bail:
mlog_exit(status);
return status;fs/ocfs2/alloc.c +2
-0@@ -5929,6 +5930,8 @@ static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, i--; } + osb->truncated_clusters =0 ; +bail:
mlog_exit(status);
return status;fs/ocfs2/aops.c +0
-0@@ -1642,6 +1642,43 @@ static int ocfs2_zero_tail(struct inode *inode,struct buffer_head *di_bh, return ret; }Quoted 10 lines
Quoted 8 lines
fs/ocfs2/aops.c +4
-0+/* +* Try to flush truncate log if we can free enough clusters from it. +* As for return value, "< 0" means error, "0" no space and "1" means +* we have freed enough spaces and let the caller try to allocate again.
+ */
+static int ocfs2_try_to_free_truncate_log(structocfs2_super*osb,
+ unsigned int needed)why not use 'unsigned int *needed, and return the actual cluster being freed.
Quoted 9 lines
I don't think we need to return 'freed clusters' here(which indicates we will flush the truncate log no matter 'needed' is). what I want is that if we can free 'needed', just do it. If not, go 'exit' because even if we free some clusters, it can't fit our need and the allocation would still fail. 'Free some clusters' here means that we have to flush the truncate log and wait for the journal commit. It is a bit time-consuming, so why let the user wait for some time(for freeing some clusters in truncate log) while eventually he will get an ENOSPC?
Alright.
Quoted 85 lines
Quoted 77 lines
Quoted 69 lines
fs/ocfs2/aops.c +30
-0+{ +tid_t target; +int ret =0 ; +unsigned int truncated_clusters; + +mutex_lock (&osb->osb_tl_inode->i_mutex); + truncated_clusters = osb->truncated_clusters; +mutex_unlock (&osb->osb_tl_inode->i_mutex); + +/* +* Check whether we can succeed in allocating if we free +* the truncate log. +*/ +if (truncated_clusters < needed) + goto out; + + ret =ocfs2_flush_truncate_log (osb); +if (ret) { +mlog_errno (ret); + goto out; + } + +if (jbd2_journal_start_commit (osb->journal->j_journal, &target)) { +jbd2_log_wait_commit (osb->journal->j_journal, target); + ret =1 ; + } +out: +return ret; +} +int ocfs2_write_begin_nolock(struct file *filp,
structaddress_space*mapping,loff_tpos, unsigned len, unsigned flags,fs/ocfs2/aops.c +5
-1@@ -1649,7 +1686,7 @@ int ocfs2_write_begin_nolock(struct file *filp, struct buffer_head *di_bh, struct page *mmap_page) { int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS; -unsigned int clusters_to_alloc, extents_to_split; +unsigned int clusters_to_alloc, extents_to_split, clusters_need =0 ;struct ocfs2_write_ctxt *wc;struct inode *inode = mapping->host;struct ocfs2_super *osb =OCFS2_SB (inode->i_sb);@@ -1658,7 +1695,9 @@ int ocfs2_write_begin_nolock(struct file *filp,struct ocfs2_alloc_context *meta_ac =NULL ;handle_t *handle;struct ocfs2_extent_tree et; +int try_free =0 , ret1; +try_again: ret =ocfs2_alloc_write_ctxt (&wc, osb, pos, len, di_bh);if (ret) {mlog_errno (ret);@@ -1693,6 +1732,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; }else if (ret ==1 ) { + clusters_need = wc->w_clen; ret =ocfs2_refcount_cow (inode, filp, di_bh, wc->w_cpos, wc->w_clen,UINT_MAX );if (ret) {@@ -1707,6 +1747,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; } + clusters_need += clusters_to_alloc; di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;fs/ocfs2/aops.c out: · line 1874
Quoted 5 lines
fs/ocfs2/aops.c +2
-0@@ -1829,6 +1870,22 @@ out:ocfs2_free_alloc_context (data_ac);if (meta_ac)ocfs2_free_alloc_context (meta_ac); + +if (ret == -ENOSPC && !try_free) {Literally, if (ret ==
-ENOSPC&&try_free) make more sense here for a better readability;-)Quoted 3 lines
You can set the
try_freewith a fixed value at the very beginning, which in other words, means set the
retry times we're allowing to perform after the allocation failure.Is it really needed for the user to try several times? I am not sure. Yes, we can try several times, but if the first try doesn't work, do you think we can have another chance that some other process just happen to truncate and fill in the truncate log for us between 2 tries?
Quoted 5 lines
If yes, it is hard for us to tell how many times is appropriate to try. If the system is in this stage(nearly full and needs a truncate log flush to allocate clusters), I guess the right step is let the user know
-ENOSPCdoes happen(if flush truncate log doesn't help either) and do something instead.
Yep, the retry time was not that easy to evaluate, the original intention from me is to use 'try_free' instead
of '!try_free' to judge if we perform truncate log flushing or not, just for a better readability;)
Quoted 3 lines
Regards,
Tao
PATCH 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
In reply to Tao MaQuoted 9 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
Quoted 5 lines
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.
Ok, this is more like what I was thinking about. I guess I wish
we could do it inside the allocation routines, but I think we have too many locks at that point. This patch doesn't help any place that allocates other than write() and mmap(). Is this something that could be added to extending truncate and unwritten allocation?
I agree that we only care to have one pass. Have you run it
against the test case from
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288? If so, modulo any cleanups you did after others commented, I'm happy ;-)
Joel
fs/ocfs2/ocfs2.h struct ocfs2_super · line 443
Quoted 10 lines
fs/ocfs2/ocfs2.h +2
-0@@ -439,6 +439,8 @@ struct ocfs2_super/* rb tree root for refcount lock. */ struct rb_root osb_rf_lock_tree;struct ocfs2_refcount_tree *osb_ref_tree_lru; + +unsigned int truncated_clusters;
Make sure you comment what lock is needed to accesstruncated_clusters.
Signature · 9 lines
Life's Little Instruction Book #232 "Keep your promises." Joel Becker Senior Development Manager Oracle E-mail: joel.becker at oracle.com Phone: (650) 506-8127
PATCH 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Quoted 16 lines · Joel Becker
Quoted 9 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
Quoted 5 lines
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh<[email protected]>. Thanks.
Quoted 3 lines
Ok, this is more like what I was thinking about. I guess I wish
we could do it inside the allocation routines, but I think we have too many locks at that point.
yeah, the locks are really the biggest problem for us.
Quoted 3 lines
This patch doesn't help any place that
allocates other thanwrite()andmmap(). Is this something that could be added to extending truncate and unwritten allocation?
I haven't tried in other cases. but in general it could be possible since all the work is done in ocfs2_try_to_free_truncate_log. We may try it in other place after thinking carefully of the lock there. But I guess we can let it in first to see how it works. If it is right and robust, I can generate another patch for them later. :)
Quoted 4 lines
I agree that we only care to have one pass. Have you run it
against the test case from
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288? If so, modulo any cleanups you did after others commented, I'm happy ;-)
yes, I have run the test case overnight and didn't hit ENOSPC any more. So do you think of accepting it? If yes, I will regenerate the patch for your merge.
Quoted 14 lines
fs/ocfs2/ocfs2.h struct ocfs2_super · line 443
Quoted 11 lines
fs/ocfs2/ocfs2.h +2
-0@@ -439,6 +439,8 @@ struct ocfs2_super/* rb tree root for refcount lock. */ struct rb_root osb_rf_lock_tree;struct ocfs2_refcount_tree *osb_ref_tree_lru; + +unsigned int truncated_clusters;Make sure you comment what lock is needed to access
truncated_clusters.
OK, I will add comment for it.
Regards,
Tao
PATCH 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Quoted 3 lines · Tao Ma
yes, I have run the test case overnight and didn't hit ENOSPC any more. So do you think of accepting it? If yes, I will regenerate the patch for your merge.
Please do. Thanks.
Joel
Signature · 9 lines
"The question of whether computers can think is just like the question of whether submarines can swim." - Edsger W. Dijkstra Joel Becker Senior Development Manager Oracle E-mail: joel.becker at oracle.com Phone: (650) 506-8127
PATCH v2 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
In reply to Tao MaRecently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288
The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
So this patch just try to resolve it. In case we see -ENOSPC in ocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.
--- fs/ocfs2/alloc.c | 3 ++ fs/ocfs2/aops.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++- fs/ocfs2/ocfs2.h | 5 ++++ 3 files changed, 66 insertions(+), 1 deletions(-)
fs/ocfs2/alloc.c +3 -0
@@ -5858,6 +5858,7 @@ int ocfs2_truncate_log_append(struct ocfs2_super *osb,ocfs2_journal_dirty (handle, tl_bh); + osb->truncated_clusters += num_clusters; bail:mlog_exit (status);return status;
@@ -5929,6 +5930,8 @@ static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, i--; } + osb->truncated_clusters =0 ; + bail:mlog_exit (status);return status;
fs/ocfs2/aops.c +58 -1
96 lines not on this page · raw message
fs/ocfs2/ocfs2.h +5 -0
@@ -420,6 +420,11 @@ struct ocfs2_superstruct inode *osb_tl_inode;struct buffer_head *osb_tl_bh;struct delayed_work osb_truncate_log_wq; +/* +* How many clusters in our truncate log. +* It must be protected by osb_tl_inode->i_mutex. +*/ +unsigned int truncated_clusters;struct ocfs2_node_map osb_recovering_orphan_dirs;unsigned int *osb_orphan_wipes;
Signature · 1 line
1.7.1.571.gba4d01
PATCH v2 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Quoted 9 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
Quoted 5 lines
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.
I think I like this. Anyone have any objections?
Joel
Signature · 7 lines
"Every new beginning comes from some other beginning's end." Joel Becker Senior Development Manager Oracle E-mail: joel.becker at oracle.com Phone: (650) 506-8127
PATCH v2 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
Quoted 10 lines · Joel Becker
Quoted 9 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
Quoted 6 lines
Quoted 5 lines
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh<[email protected]>. Thanks.I think I like this. Anyone have any objections?
Looks good.
PATCH v2 1/1 ocfs2: Try to free truncate log when meeting ENOSPC in write.
In reply to Tao MaQuoted 9 lines · Tao Ma
Recently, one of our colleagues meet with a problem that if we write/delete a 32mb files repeatly, we will get an ENOSPC in the end. And the corresponding bug is 1288.
http://oss.oracle.com/bugzilla/show_bug.cgi?id=1288The real problem is that although we have freed the clusters, they are in truncate log and they will be summed up so that we can free them once in a whole.
Quoted 8 lines
So this patch just try to resolve it. In case we see
-ENOSPCinocfs2_write_begin_no_lock, we will check whether the truncate log has enough clusters for our need, if yes, we will try to flush the truncate log at that point and try again. This method is inspired by Mark Fasheh <[email protected]>. Thanks.Cc Mark Fasheh <[email protected]>Signed-off-by Tao Ma <[email protected]>
This is now in the merge-window branch of ocfs2.git.
Joel
Quoted 152 lines
--- fs/ocfs2/alloc.c | 3 ++ fs/ocfs2/aops.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++- fs/ocfs2/ocfs2.h | 5 ++++ 3 files changed, 66 insertions(+), 1 deletions(-)fs/ocfs2/alloc.c +3
-0@@ -5858,6 +5858,7 @@ int ocfs2_truncate_log_append(struct ocfs2_super *osb,ocfs2_journal_dirty (handle, tl_bh); + osb->truncated_clusters += num_clusters; bail:mlog_exit (status);return status;@@ -5929,6 +5930,8 @@ static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, i--; } + osb->truncated_clusters =0 ; + bail:mlog_exit (status);return status;fs/ocfs2/aops.c +58
-1@@ -1642,6 +1642,43 @@ static int ocfs2_zero_tail(struct inode *inode, struct buffer_head *di_bh,return ret; } +/* +* Try to flush truncate logs if we can free enough clusters from it. +* As for return value, "< 0" means error, "0" no space and "1" means +* we have freed enough spaces and let the caller try to allocate again. +*/ +static int ocfs2_try_to_free_truncate_log (struct ocfs2_super *osb, +unsigned int needed) +{ +tid_t target; +int ret =0 ; +unsigned int truncated_clusters; + +mutex_lock (&osb->osb_tl_inode->i_mutex); + truncated_clusters = osb->truncated_clusters; +mutex_unlock (&osb->osb_tl_inode->i_mutex); + +/* +* Check whether we can succeed in allocating if we free +* the truncate log. +*/ +if (truncated_clusters < needed) + goto out; + + ret =ocfs2_flush_truncate_log (osb); +if (ret) { +mlog_errno (ret); + goto out; + } + +if (jbd2_journal_start_commit (osb->journal->j_journal, &target)) { +jbd2_log_wait_commit (osb->journal->j_journal, target); + ret =1 ; + } +out: +return ret; +} + int ocfs2_write_begin_nolock(struct file *filp, struct address_space *mapping, loff_t pos, unsigned len, unsigned flags,@@ -1649,7 +1686,7 @@ int ocfs2_write_begin_nolock(struct file *filp, struct buffer_head *di_bh, struct page *mmap_page) { int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS; -unsigned int clusters_to_alloc, extents_to_split; +unsigned int clusters_to_alloc, extents_to_split, clusters_need =0 ;struct ocfs2_write_ctxt *wc;struct inode *inode = mapping->host;struct ocfs2_super *osb =OCFS2_SB (inode->i_sb);@@ -1658,7 +1695,9 @@ int ocfs2_write_begin_nolock(struct file *filp,struct ocfs2_alloc_context *meta_ac =NULL ;handle_t *handle;struct ocfs2_extent_tree et; +int try_free =1 , ret1; +try_again: ret =ocfs2_alloc_write_ctxt (&wc, osb, pos, len, di_bh);if (ret) {mlog_errno (ret);@@ -1693,6 +1732,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; }else if (ret ==1 ) { + clusters_need = wc->w_clen; ret =ocfs2_refcount_cow (inode, filp, di_bh, wc->w_cpos, wc->w_clen,UINT_MAX );if (ret) {@@ -1707,6 +1747,7 @@ int ocfs2_write_begin_nolock(struct file *filp,mlog_errno (ret); goto out; } + clusters_need += clusters_to_alloc; di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;@@ -1829,6 +1870,22 @@ out:ocfs2_free_alloc_context (data_ac);if (meta_ac)ocfs2_free_alloc_context (meta_ac); + +if (ret == -ENOSPC && try_free) { +/* +* Try to free some truncate log so that we can have enough +* clusters to allocate. +*/ + try_free =0 ; + + ret1 =ocfs2_try_to_free_truncate_log (osb, clusters_need); +if (ret1 ==1 ) + goto try_again; + +if (ret1 <0 ) +mlog_errno (ret1); + } +return ret; }fs/ocfs2/ocfs2.h +5
-0@@ -420,6 +420,11 @@ struct ocfs2_superstruct inode *osb_tl_inode;struct buffer_head *osb_tl_bh;struct delayed_work osb_truncate_log_wq; +/* +* How many clusters in our truncate log. +* It must be protected by osb_tl_inode->i_mutex. +*/ +unsigned int truncated_clusters;struct ocfs2_node_map osb_recovering_orphan_dirs;unsigned int *osb_orphan_wipes;Signature · 1 line
1.7.1.571.gba4d01
Signature · 8 lines
"Egotist: a person more interested in himself than in me."
- Ambrose Bierce
Joel Becker
Senior Development Manager
Oracle
E-mail: joel.becker at oracle.com
Phone: (650) 506-8127