ceph: fix long stalls on sync/syncfs
v3 cover ceph: fix long stalls on sync/syncfs
Just a small update from the last version. This adds a new helper function to handle moving the inode to the appropriate lists when auth caps change.
Also, remove a FIXME comment I had added as I think I've answered the question on that for now (and a later patch will fix it).
Jeff Layton (2):
ceph: convert mdsc->cap_dirty to a per-session list
ceph: request expedited service on session's last cap flush
fs/ceph/caps.c | 86 ++++++++++++++++++++++++++++++++++++-------- fs/ceph/mds_client.c | 2 +- fs/ceph/mds_client.h | 5 +-- fs/ceph/super.h | 19 ++++++++-- 4 files changed, 91 insertions(+), 21 deletions(-)
Signature · 1 line
2.25.1
PATCH v3 1/2 ceph: convert mdsc->cap_dirty to a per-session list
This is a per-sb list now, but that makes it difficult to tell when the cap is the last dirty one associated with the session. Switch this to be a per-session list, but continue using the mdsc->cap_dirty_lock to protect the lists.
This list is only ever walked in ceph_flush_dirty_caps, so change that to walk the sessions array and then flush the caps for inodes on each session's list.
If the auth cap ever changes while the inode has dirty caps, then move the inode to the appropriate session for the new auth_cap. Also, ensure that we never remove an auth cap while the inode is still on the s_cap_dirty list.
--- fs/ceph/caps.c | 78 ++++++++++++++++++++++++++++++++++++-------- fs/ceph/mds_client.c | 2 +- fs/ceph/mds_client.h | 5 +-- fs/ceph/super.h | 19 +++++++++-- 4 files changed, 85 insertions(+), 19 deletions(-)
fs/ceph/caps.c +65 -13
@@ -597,6 +597,27 @@ static void __check_cap_issue(struct ceph_inode_info *ci, struct ceph_cap *cap, } } +/** +* change_auth_cap_ses - move inode to appropriate lists when auth caps change +* @ci: inode to be moved +* @session: new auth caps session +*/ +static void change_auth_cap_ses (struct ceph_inode_info *ci, +struct ceph_mds_session *session) +{ +lockdep_assert_held (&ci->i_ceph_lock); + +if (list_empty (&ci->i_dirty_item) &&list_empty (&ci->i_flushing_item)) +return ; + +spin_lock (&session->s_mdsc->cap_dirty_lock); +if (!list_empty (&ci->i_dirty_item)) +list_move (&ci->i_dirty_item, &session->s_cap_dirty); +if (!list_empty (&ci->i_flushing_item)) +list_move_tail (&ci->i_flushing_item, &session->s_cap_flushing); +spin_unlock (&session->s_mdsc->cap_dirty_lock); +} +/* * Add a capability under the given MDS session. *
@@ -727,6 +748,9 @@ void ceph_add_cap(struct inode *inode,if (flags &CEPH_CAP_FLAG_AUTH ) {if (!ci->i_auth_cap ||ceph_seq_cmp (ci->i_auth_cap->mseq, mseq) <0 ) { +if (ci->i_auth_cap && + ci->i_auth_cap->session != cap->session) +change_auth_cap_ses (ci, cap->session); ci->i_auth_cap = cap; cap->mds_wanted = wanted; }
@@ -1123,8 +1147,10 @@ void __ceph_remove_cap(struct ceph_cap *cap, bool queue_release)/* remove from inode's cap rbtree, and clear auth cap */ rb_erase (&cap->ci_node, &ci->i_caps); -if (ci->i_auth_cap == cap) +if (ci->i_auth_cap == cap) { +WARN_ON_ONCE (!list_empty (&ci->i_dirty_item)); ci->i_auth_cap =NULL ; + }/* remove from session list */ spin_lock (&session->s_cap_lock);
@@ -1690,6 +1716,8 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask, ceph_cap_string(was | mask)); ci->i_dirty_caps |= mask;if (was ==0 ) { +struct ceph_mds_session *session = ci->i_auth_cap->session; +WARN_ON_ONCE (ci->i_prealloc_cap_flush);swap (ci->i_prealloc_cap_flush, *pcf);
@@ -1702,7 +1730,7 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask, &ci->vfs_inode, ci->i_head_snapc, ci->i_auth_cap);BUG_ON (!list_empty (&ci->i_dirty_item));spin_lock (&mdsc->cap_dirty_lock); -list_add (&ci->i_dirty_item, &mdsc->cap_dirty); +list_add (&ci->i_dirty_item, &session->s_cap_dirty);spin_unlock (&mdsc->cap_dirty_lock);if (ci->i_flushing_caps ==0 ) {ihold (inode);
@@ -3750,15 +3778,9 @@ static void handle_cap_export(struct inode *inode, struct ceph_mds_caps *ex, tcap->issue_seq = t_seq -1 ; tcap->issued |= issued; tcap->implemented |= issued; -if (cap == ci->i_auth_cap) +if (cap == ci->i_auth_cap) { ci->i_auth_cap = tcap; - -if (!list_empty (&ci->i_cap_flush_list) && - ci->i_auth_cap == tcap) { -spin_lock (&mdsc->cap_dirty_lock); -list_move_tail (&ci->i_flushing_item, - &tcap->session->s_cap_flushing); -spin_unlock (&mdsc->cap_dirty_lock); +change_auth_cap_ses (ci, tcap->session); } }__ceph_remove_cap (cap, false);
@@ -4176,15 +4198,16 @@ void ceph_check_delayed_caps(struct ceph_mds_client *mdsc)/* * Flush all dirty caps to the mds */ -void ceph_flush_dirty_caps (struct ceph_mds_client *mdsc) +static void flush_dirty_session_caps (struct ceph_mds_session *s) { +struct ceph_mds_client *mdsc = s->s_mdsc;struct ceph_inode_info *ci;struct inode *inode;dout ("flush_dirty_caps\n" );spin_lock (&mdsc->cap_dirty_lock); -while (!list_empty (&mdsc->cap_dirty)) { - ci = list_first_entry(&mdsc->cap_dirty, struct ceph_inode_info, +while (!list_empty (&s->s_cap_dirty)) { + ci = list_first_entry(&s->s_cap_dirty, struct ceph_inode_info, i_dirty_item); inode = &ci->vfs_inode;ihold (inode);
@@ -4198,6 +4221,35 @@ void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)dout ("flush_dirty_caps done\n" ); } +static void iterate_sessions (struct ceph_mds_client *mdsc, +void (*cb)(struct ceph_mds_session *)) +{ +int mds; + +mutex_lock (&mdsc->mutex); +for (mds =0 ; mds < mdsc->max_sessions; ++mds) { +struct ceph_mds_session *s; + +if (!mdsc->sessions[mds]) +continue ; + + s =ceph_get_mds_session (mdsc->sessions[mds]); +if (!s) +continue ; + +mutex_unlock (&mdsc->mutex); +cb (s); +ceph_put_mds_session (s); +mutex_lock (&mdsc->mutex); + }; +mutex_unlock (&mdsc->mutex); +} + +void ceph_flush_dirty_caps (struct ceph_mds_client *mdsc) +{ +iterate_sessions (mdsc, flush_dirty_session_caps); +} +void __ceph_touch_fmode (struct ceph_inode_info *ci,struct ceph_mds_client *mdsc,int fmode) {
fs/ceph/mds_client.c +1 -1
@@ -755,6 +755,7 @@ static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc,INIT_LIST_HEAD (&s->s_cap_releases);INIT_WORK (&s->s_cap_release_work, ceph_cap_release_work); +INIT_LIST_HEAD (&s->s_cap_dirty);INIT_LIST_HEAD (&s->s_cap_flushing); mdsc->sessions[mds] = s;
@@ -4375,7 +4376,6 @@ int ceph_mdsc_init(struct ceph_fs_client *fsc)spin_lock_init (&mdsc->snap_flush_lock); mdsc->last_cap_flush_tid =1 ;INIT_LIST_HEAD (&mdsc->cap_flush_list); -INIT_LIST_HEAD (&mdsc->cap_dirty);INIT_LIST_HEAD (&mdsc->cap_dirty_migrating); mdsc->num_cap_flushing =0 ;spin_lock_init (&mdsc->cap_dirty_lock);
fs/ceph/mds_client.h +3 -2
@@ -199,8 +199,10 @@ struct ceph_mds_session {struct list_head s_cap_releases;/* waiting cap_release messages */ struct work_struct s_cap_release_work; -/* protected by mutex */ +/* both protected by s_mdsc->cap_dirty_lock */ +struct list_head s_cap_dirty;/* inodes w/ dirty caps */ struct list_head s_cap_flushing;/* inodes w/ flushing caps */ +unsigned long s_renew_requested;/* last time we sent a renew req */ u64 s_renew_seq;
@@ -424,7 +426,6 @@ struct ceph_mds_client {u64 last_cap_flush_tid;struct list_head cap_flush_list; -struct list_head cap_dirty;/* inodes with dirty caps */ struct list_head cap_dirty_migrating;/* ...that are migration... */ int num_cap_flushing;/* # caps we are flushing */ spinlock_t cap_dirty_lock;/* protects above items */
fs/ceph/super.h +16 -3
@@ -351,9 +351,22 @@ struct ceph_inode_info {struct rb_root i_caps;/* cap list */ struct ceph_cap *i_auth_cap;/* authoritative cap, if any */ unsigned i_dirty_caps, i_flushing_caps;/* mask of dirtied fields */ -struct list_head i_dirty_item, i_flushing_item;/* protected by -* mdsc->cap_dirty_lock -*/ + +/* +* Link to the the auth cap's session's s_cap_dirty list. s_cap_dirty +* is protected by the mdsc->cap_dirty_lock, but each individual item +* is also protected by the inode's i_ceph_lock. Walking s_cap_dirty +* requires the mdsc->cap_dirty_lock. List presence for an item can +* be tested under the i_ceph_lock. Changing anything requires both. +*/ +struct list_head i_dirty_item; + +/* +* Link to session's s_cap_flushing list. Protected by +* mdsc->cap_dirty_lock. +*/ +struct list_head i_flushing_item; +/* we need to track cap writeback on a per-cap-bit basis, to allow * overlapping, pipelined cap flushes to the mds. we can probably * reduce the tid to 8 bits if we're concerned about inode size. */
Signature · 1 line
2.25.1
Re: [PATCH v3 1/2] ceph: convert mdsc->cap_dirty to a per-session list
Quoted 244 lines · Jeff Layton
This is a per-sb list now, but that makes it difficult to tell when the cap is the last dirty one associated with the session. Switch this to be a per-session list, but continue using the
mdsc->cap_dirty_lockto protect the lists.This list is only ever walked in
ceph_flush_dirty_caps, so change that to walk the sessions array and then flush the caps for inodes on each session's list.If the auth cap ever changes while the inode has dirty caps, then move the inode to the appropriate session for the new
auth_cap. Also, ensure that we never remove an auth cap while the inode is still on thes_cap_dirtylist.Signed-off-by Jeff Layton <[email protected]>--- fs/ceph/caps.c | 78 ++++++++++++++++++++++++++++++++++++-------- fs/ceph/mds_client.c | 2 +- fs/ceph/mds_client.h | 5 +-- fs/ceph/super.h | 19 +++++++++-- 4 files changed, 85 insertions(+), 19 deletions(-)fs/ceph/caps.c +65
-13@@ -597,6 +597,27 @@ static void __check_cap_issue(struct ceph_inode_info *ci, struct ceph_cap *cap, } } +/** +* change_auth_cap_ses - move inode to appropriate lists when auth caps change +* @ci: inode to be moved +* @session: new auth caps session +*/ +static void change_auth_cap_ses (struct ceph_inode_info *ci, +struct ceph_mds_session *session) +{ +lockdep_assert_held (&ci->i_ceph_lock); + +if (list_empty (&ci->i_dirty_item) &&list_empty (&ci->i_flushing_item)) +return ; + +spin_lock (&session->s_mdsc->cap_dirty_lock); +if (!list_empty (&ci->i_dirty_item)) +list_move (&ci->i_dirty_item, &session->s_cap_dirty); +if (!list_empty (&ci->i_flushing_item)) +list_move_tail (&ci->i_flushing_item, &session->s_cap_flushing); +spin_unlock (&session->s_mdsc->cap_dirty_lock); +} +/* * Add a capability under the given MDS session. * @@ -727,6 +748,9 @@ void ceph_add_cap(struct inode *inode,if (flags &CEPH_CAP_FLAG_AUTH ) {if (!ci->i_auth_cap ||ceph_seq_cmp (ci->i_auth_cap->mseq, mseq) <0 ) { +if (ci->i_auth_cap && + ci->i_auth_cap->session != cap->session) +change_auth_cap_ses (ci, cap->session); ci->i_auth_cap = cap; cap->mds_wanted = wanted; }@@ -1123,8 +1147,10 @@ void __ceph_remove_cap(struct ceph_cap *cap, bool queue_release)/* remove from inode's cap rbtree, and clear auth cap */ rb_erase (&cap->ci_node, &ci->i_caps); -if (ci->i_auth_cap == cap) +if (ci->i_auth_cap == cap) { +WARN_ON_ONCE (!list_empty (&ci->i_dirty_item)); ci->i_auth_cap =NULL ; + }/* remove from session list */ spin_lock (&session->s_cap_lock);@@ -1690,6 +1716,8 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask, ceph_cap_string(was | mask)); ci->i_dirty_caps |= mask;if (was ==0 ) { +struct ceph_mds_session *session = ci->i_auth_cap->session; +WARN_ON_ONCE (ci->i_prealloc_cap_flush);swap (ci->i_prealloc_cap_flush, *pcf);@@ -1702,7 +1730,7 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask, &ci->vfs_inode, ci->i_head_snapc, ci->i_auth_cap);BUG_ON (!list_empty (&ci->i_dirty_item));spin_lock (&mdsc->cap_dirty_lock); -list_add (&ci->i_dirty_item, &mdsc->cap_dirty); +list_add (&ci->i_dirty_item, &session->s_cap_dirty);spin_unlock (&mdsc->cap_dirty_lock);if (ci->i_flushing_caps ==0 ) {ihold (inode);@@ -3750,15 +3778,9 @@ static void handle_cap_export(struct inode *inode, struct ceph_mds_caps *ex, tcap->issue_seq = t_seq -1 ; tcap->issued |= issued; tcap->implemented |= issued; -if (cap == ci->i_auth_cap) +if (cap == ci->i_auth_cap) { ci->i_auth_cap = tcap; - -if (!list_empty (&ci->i_cap_flush_list) && - ci->i_auth_cap == tcap) { -spin_lock (&mdsc->cap_dirty_lock); -list_move_tail (&ci->i_flushing_item, - &tcap->session->s_cap_flushing); -spin_unlock (&mdsc->cap_dirty_lock); +change_auth_cap_ses (ci, tcap->session); } }__ceph_remove_cap (cap, false);@@ -4176,15 +4198,16 @@ void ceph_check_delayed_caps(struct ceph_mds_client *mdsc)/* * Flush all dirty caps to the mds */ -void ceph_flush_dirty_caps (struct ceph_mds_client *mdsc) +static void flush_dirty_session_caps (struct ceph_mds_session *s) { +struct ceph_mds_client *mdsc = s->s_mdsc;struct ceph_inode_info *ci;struct inode *inode;dout ("flush_dirty_caps\n" );spin_lock (&mdsc->cap_dirty_lock); -while (!list_empty (&mdsc->cap_dirty)) { - ci = list_first_entry(&mdsc->cap_dirty, struct ceph_inode_info, +while (!list_empty (&s->s_cap_dirty)) { + ci = list_first_entry(&s->s_cap_dirty, struct ceph_inode_info, i_dirty_item); inode = &ci->vfs_inode;ihold (inode);@@ -4198,6 +4221,35 @@ void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)dout ("flush_dirty_caps done\n" ); } +static void iterate_sessions (struct ceph_mds_client *mdsc, +void (*cb)(struct ceph_mds_session *)) +{ +int mds; + +mutex_lock (&mdsc->mutex); +for (mds =0 ; mds < mdsc->max_sessions; ++mds) { +struct ceph_mds_session *s; + +if (!mdsc->sessions[mds]) +continue ; + + s =ceph_get_mds_session (mdsc->sessions[mds]); +if (!s) +continue ; + +mutex_unlock (&mdsc->mutex); +cb (s); +ceph_put_mds_session (s); +mutex_lock (&mdsc->mutex); + }; +mutex_unlock (&mdsc->mutex); +} + +void ceph_flush_dirty_caps (struct ceph_mds_client *mdsc) +{ +iterate_sessions (mdsc, flush_dirty_session_caps); +} +void __ceph_touch_fmode (struct ceph_inode_info *ci,struct ceph_mds_client *mdsc,int fmode) {fs/ceph/mds_client.c +1
-1@@ -755,6 +755,7 @@ static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc,INIT_LIST_HEAD (&s->s_cap_releases);INIT_WORK (&s->s_cap_release_work, ceph_cap_release_work); +INIT_LIST_HEAD (&s->s_cap_dirty);INIT_LIST_HEAD (&s->s_cap_flushing); mdsc->sessions[mds] = s;@@ -4375,7 +4376,6 @@ int ceph_mdsc_init(struct ceph_fs_client *fsc)spin_lock_init (&mdsc->snap_flush_lock); mdsc->last_cap_flush_tid =1 ;INIT_LIST_HEAD (&mdsc->cap_flush_list); -INIT_LIST_HEAD (&mdsc->cap_dirty);INIT_LIST_HEAD (&mdsc->cap_dirty_migrating); mdsc->num_cap_flushing =0 ;spin_lock_init (&mdsc->cap_dirty_lock);fs/ceph/mds_client.h +3
-2@@ -199,8 +199,10 @@ struct ceph_mds_session {struct list_head s_cap_releases;/* waiting cap_release messages */ struct work_struct s_cap_release_work; -/* protected by mutex */ +/* both protected by s_mdsc->cap_dirty_lock */ +struct list_head s_cap_dirty;/* inodes w/ dirty caps */ struct list_head s_cap_flushing;/* inodes w/ flushing caps */ +unsigned long s_renew_requested;/* last time we sent a renew req */ u64 s_renew_seq;@@ -424,7 +426,6 @@ struct ceph_mds_client {u64 last_cap_flush_tid;struct list_head cap_flush_list; -struct list_head cap_dirty;/* inodes with dirty caps */ struct list_head cap_dirty_migrating;/* ...that are migration... */ int num_cap_flushing;/* # caps we are flushing */ spinlock_t cap_dirty_lock;/* protects above items */ fs/ceph/super.h +16
-4@@ -351,9 +351,22 @@ struct ceph_inode_info {struct rb_root i_caps;/* cap list */ struct ceph_cap *i_auth_cap;/* authoritative cap, if any */ unsigned i_dirty_caps, i_flushing_caps;/* mask of dirtied fields */ -struct list_head i_dirty_item, i_flushing_item;/* protected by -* mdsc->cap_dirty_lock -*/ + +/* +* Link to the the auth cap's session's s_cap_dirty list. s_cap_dirty +* is protected by the mdsc->cap_dirty_lock, but each individual item +* is also protected by the inode's i_ceph_lock. Walking s_cap_dirty +* requires the mdsc->cap_dirty_lock. List presence for an item can +* be tested under the i_ceph_lock. Changing anything requires both. +*/ +struct list_head i_dirty_item; + +/* +* Link to session's s_cap_flushing list. Protected by +* mdsc->cap_dirty_lock. +*/ +struct list_head i_flushing_item; +/* we need to track cap writeback on a per-cap-bit basis, to allow * overlapping, pipelined cap flushes to the mds. we can probably * reduce the tid to 8 bits if we're concerned about inode size. */ --
Quoted 2 lines
2.25.1
PATCH v3 2/2 ceph: request expedited service on session's last cap flush
In reply to Jeff LaytonWhen flushing a lot of caps to the MDS's at once (e.g. for syncfs), we can end up waiting a substantial amount of time for MDS replies, due to the fact that it may delay some of them so that it can batch them up together in a single journal transaction. This can lead to stalls when calling sync or syncfs.
What we'd really like to do is request expedited service on the _last_ cap we're flushing back to the server. If the CHECK_CAPS_FLUSH flag is set on the request and the current inode was the last one on the session->s_cap_dirty list, then mark the request with CEPH_CLIENT_CAPS_SYNC.
Note that this heuristic is not perfect. New inodes can race onto the list after we've started flushing, but it does seem to fix some common use cases.
URL: https://tracker.ceph.com/issues/44744
--- fs/ceph/caps.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
fs/ceph/caps.c +6 -2
@@ -1998,6 +1998,7 @@ void ceph_check_caps(struct ceph_inode_info *ci, int flags, }for (p =rb_first (&ci->i_caps); p; p =rb_next (p)) { +int mflags =0 ;struct cap_msg_args arg; cap = rb_entry(p, struct ceph_cap, ci_node);
@@ -2129,6 +2130,9 @@ void ceph_check_caps(struct ceph_inode_info *ci, int flags, flushing = ci->i_dirty_caps; flush_tid =__mark_caps_flushing (inode, session, false, &oldest_flush_tid); +if (flags &CHECK_CAPS_FLUSH && +list_empty (&session->s_cap_dirty)) + mflags |=CEPH_CLIENT_CAPS_SYNC ; }else { flushing =0 ; flush_tid =0 ;
@@ -2139,8 +2143,8 @@ void ceph_check_caps(struct ceph_inode_info *ci, int flags, mds = cap->mds;/* remember mds, so we don't repeat */ -__prep_cap (&arg, cap,CEPH_CAP_OP_UPDATE ,0 , cap_used, want, - retain, flushing, flush_tid, oldest_flush_tid); +__prep_cap (&arg, cap,CEPH_CAP_OP_UPDATE , mflags, cap_used, + want, retain, flushing, flush_tid, oldest_flush_tid);spin_unlock (&ci->i_ceph_lock);__send_cap (mdsc, &arg, ci);
Signature · 1 line
2.25.1